@adatechnology/game-crowd 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,2308 @@
+// src/crowd.ts
+import { createCorpseLedger } from "@adatechnology/game-characters";
+
+// src/data/defaults.json
+var defaults_default = {
+  sources: {
+    store: "jogo.js G 66714-66734 (Z, ZMAX 6000, FIELDS)",
+    bands: "jogo.js G 62019-62020 (BANDS, HYST)",
+    flow: "jogo.js G 66735-66737, 66773-66825 (FLOW_R 192, flowStart, flowStep; budget 1 ms a frame, the first field in one go)",
+    update: "jogo.js G 66835-66977 hordeUpdate",
+    alerts: "jogo.js G 66978-66993 groan, screamAt",
+    attack: "jogo.js G 66996-67006 zAttack",
+    damage: "jogo.js G 67010-67045 zDamage",
+    kill: "jogo.js G 67046-67059 zKill, inchadoBurst",
+    corpses: "jogo.js G 62021 (CORPOS_MAX 400, CORPO_VIDA 900), 67062-67075 corpseAdd, corpsesUpdate",
+    population: "jogo.js G 67139-67177 spawnAway, populationUpdate (popTarget 1200, migration 120 every 90 s, the first after 60 s)",
+    pile: "jogo.js G 67184-67227 (PILE_STEP 0.48, PILE_TOP 3.7, PILE_MAX 160, groundAt, zBlockedAt, tryStep, stepRelease, pileBlast)",
+    trail: "jogo.js G 67238-67246 trailUpdate",
+    abilities: "jogo.js G 67266-67356 zAbility, zChaseSpeed, zHurtOther, killQ",
+    frame: "jogo.js G 67377-67402 zFrame",
+    cadence: "jogo.js G 65507 walkCad"
+  },
+  bands: [
+    { max: 35, dt: 0.05 },
+    { max: 120, dt: 0.2 },
+    { max: 400, dt: 1 },
+    { max: null, dt: 5 }
+  ],
+  numbers: {
+    capacity: 6e3,
+    hysteresis: 10,
+    flowRadius: 192,
+    flowBudgetMs: 1,
+    hashCell: 1,
+    nightSight: 0.4,
+    crouchSight: 0.6,
+    sightCone: 0.5,
+    sightNear: 2.5,
+    loseAfter: 15,
+    hearingBase: 40,
+    heardLost: 5,
+    alertRadius: 8,
+    alertDelay: 0.2,
+    alertDelayRandom: 0.4,
+    voiceDistance: 40,
+    voiceEvery: 0.25,
+    directRange: 4,
+    pyramidRange: 14,
+    screamSpeed: 1.2,
+    attackRange: 1.15,
+    attackHeight: 1.3,
+    attackSlots: 6,
+    attackEvery: 1.5,
+    crouchBite: 1.3,
+    crawlDamage: 0.6,
+    wanderSpan: 24,
+    crawlSpeed: 0.4,
+    limpSpeed: 0.5,
+    separation: 0.31,
+    separationPush: 2.2,
+    doorDamage: 10,
+    doorMessageDistance: 25,
+    skullMinDamage: 20,
+    skullTakeDamage: 60,
+    skullTakeWithin: { "12ga": 5 },
+    jawDamage: 25,
+    jawChance: 0.3,
+    hitStunDamage: 35,
+    hitStun: 0.45,
+    dormantWake: 3,
+    dormantWakeBehind: 10,
+    pileStep: 0.48,
+    pileTop: 3.7,
+    pileMax: 160,
+    pileReleaseDistance: 30,
+    gravity: 9.8,
+    fallStun: 3.2,
+    climbSpeed: 1.9,
+    cadenceBase: 0.5,
+    cadencePerSpeed: 0.3,
+    corpsesMax: 400,
+    corpseSeconds: 900,
+    trailSeconds: 120,
+    trailStep: 1.5,
+    trailMax: 200,
+    population: 1200,
+    refillMin: 70,
+    refillMax: 160,
+    migrationFirst: 60
+  }
+};
+
+// src/doors.ts
+var DOOR_DEFAULTS = { doorHp: 300, plankHp: 150, height: 2.2, thickness: 0.1, soundChance: 0.3, soundVolume: 0.8, breakVolume: 1.5, breakNoise: 30 };
+function createDoors(grid, options) {
+  const N = { ...DOOR_DEFAULTS, ...options.numbers };
+  const random = options.random;
+  const list = [];
+  const doorAt = new Int16Array(grid.n * grid.n).fill(-1);
+  const listeners = /* @__PURE__ */ new Map();
+  const emit = (event, payload) => {
+    for (const listener of listeners.get(event) ?? []) listener(payload);
+  };
+  const set = (index, open) => {
+    const d = list[index];
+    if (!d) return;
+    d.open = open;
+    grid.fillRect(...d.rect, open || d.broken ? 3 : 5, N.height);
+  };
+  return {
+    list,
+    at: (cell) => cell < 0 ? -1 : doorAt[cell],
+    add(x, z, axis, width, data) {
+      const i = list.length;
+      const t = N.thickness;
+      const x0 = axis === "x" ? x - width / 2 : x - t;
+      const x1 = axis === "x" ? x + width / 2 : x + t;
+      const z0 = axis === "x" ? z - t : z - width / 2;
+      const z1 = axis === "x" ? z + t : z + width / 2;
+      list.push({ x, z, axis, width, hp: N.doorHp, hpMax: N.doorHp, open: false, broken: false, planks: 0, rect: [x0, z0, x1, z1], data });
+      grid.fillRect(x0, z0, x1, z1, 5, N.height);
+      const a = Math.floor((x0 + grid.half) / grid.cell);
+      const b = Math.ceil((x1 + grid.half) / grid.cell);
+      const c = Math.floor((z0 + grid.half) / grid.cell);
+      const e = Math.ceil((z1 + grid.half) / grid.cell);
+      for (let gz = c; gz < e; gz++) for (let gx = a; gx < b; gx++) doorAt[gz * grid.n + gx] = i;
+      return i;
+    },
+    set,
+    hit(index, damage) {
+      const d = list[index];
+      if (!d || d.open || d.broken) return;
+      d.hp -= damage;
+      if (random() < N.soundChance) emit("sound", { sound: "wood", volume: N.soundVolume, position: [d.x, 1, d.z] });
+      if (d.planks && d.hp < d.hpMax - d.planks * N.plankHp + N.plankHp * (d.planks - 1)) d.planks = Math.max(0, d.planks - 1);
+      if (d.hp <= 0) {
+        d.broken = true;
+        d.planks = 0;
+        set(index, true);
+        emit("noise", { x: d.x, z: d.z, radius: N.breakNoise });
+        emit("sound", { sound: "wood", volume: N.breakVolume, position: [d.x, 1, d.z] });
+        emit("effect", { effect: "dust", point: [d.x, 1, d.z], color: 9071178 });
+        emit("broken", { door: index });
+      }
+    },
+    plank(index) {
+      const d = list[index];
+      if (!d) return;
+      d.planks += 1;
+      d.hp += N.plankHp;
+      d.hpMax += N.plankHp;
+    },
+    on(event, listener) {
+      let set_ = listeners.get(event);
+      if (!set_) listeners.set(event, set_ = /* @__PURE__ */ new Set());
+      set_.add(listener);
+      return () => void set_.delete(listener);
+    }
+  };
+}
+
+// src/grid.ts
+var CELL = { FREE: 0, SOLID: 1, LOW_WALL: 2, OPEN_DOOR: 3, GLASS: 4, CLOSED_DOOR: 5 };
+var BORDER_WIDTH = 1;
+var BORDER_HEIGHT = 50;
+var LOS_STEP = 0.5;
+var LOS_HEIGHT = 1.5;
+function createNavGrid(options = {}) {
+  const size = options.size ?? 768;
+  const half = size / 2;
+  const cell = options.cell ?? 0.5;
+  const n = size / cell;
+  const occ = new Uint8Array(n * n);
+  const occH = new Float32Array(n * n);
+  const cellOf = (x, z) => {
+    const gx = Math.floor((x + half) / cell);
+    const gz = Math.floor((z + half) / cell);
+    return gx < 0 || gz < 0 || gx >= n || gz >= n ? -1 : gz * n + gx;
+  };
+  const solidAt = (x, z, y = 0.5) => {
+    const c = cellOf(x, z);
+    return c < 0 || occ[c] !== 0 && occ[c] !== 3 && occH[c] > y;
+  };
+  const fillRect = (x0, z0, x1, z1, kind, h) => {
+    const a = Math.floor((x0 + half) / cell);
+    const b = Math.ceil((x1 + half) / cell);
+    const c = Math.floor((z0 + half) / cell);
+    const d = Math.ceil((z1 + half) / cell);
+    for (let gz = Math.max(0, c); gz < Math.min(n, d); gz++)
+      for (let gx = Math.max(0, a); gx < Math.min(n, b); gx++) {
+        const i = gz * n + gx;
+        occ[i] = kind;
+        occH[i] = h;
+      }
+  };
+  if (options.border ?? true) {
+    fillRect(-half, -half, half, -half + BORDER_WIDTH, 1, BORDER_HEIGHT);
+    fillRect(-half, half - BORDER_WIDTH, half, half, 1, BORDER_HEIGHT);
+    fillRect(-half, -half, -half + BORDER_WIDTH, half, 1, BORDER_HEIGHT);
+    fillRect(half - BORDER_WIDTH, -half, half, half, 1, BORDER_HEIGHT);
+  }
+  return {
+    size,
+    half,
+    cell,
+    n,
+    occ,
+    occH,
+    cellOf,
+    solidAt,
+    cellKind: (x, z) => {
+      const c = cellOf(x, z);
+      return c < 0 ? -1 : occ[c];
+    },
+    fillRect,
+    blocked(x, z) {
+      const c = cellOf(x, z);
+      return c < 0 || occ[c] !== 0 && occ[c] !== 3;
+    },
+    losClear(x0, z0, x1, z1) {
+      const d = Math.hypot(x1 - x0, z1 - z0);
+      const steps = Math.ceil(d / LOS_STEP);
+      for (let k = 1; k < steps; k++) {
+        const t = k / steps;
+        const c = cellOf(x0 + (x1 - x0) * t, z0 + (z1 - z0) * t);
+        if (c < 0 || occ[c] === 1 && occH[c] > LOS_HEIGHT) return false;
+      }
+      return true;
+    }
+  };
+}
+
+// src/rng.ts
+function createRng(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let mixed = Math.imul(state ^ state >>> 15, state | 1);
+    mixed ^= mixed + Math.imul(mixed ^ mixed >>> 7, mixed | 61);
+    return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// src/store.ts
+var createStore = (capacity) => {
+  const f32 = () => new Float32Array(capacity);
+  const u8 = () => new Uint8Array(capacity);
+  return {
+    n: 0,
+    capacity,
+    x: f32(),
+    z: f32(),
+    vx: f32(),
+    vz: f32(),
+    yaw: f32(),
+    phase: f32(),
+    type: u8(),
+    age: u8(),
+    outfit: u8(),
+    height: f32(),
+    build: f32(),
+    chaseSpeed: f32(),
+    wanderSpeed: f32(),
+    hp: f32(),
+    hpMax: f32(),
+    headHp: f32(),
+    armHp: new Float32Array(capacity * 2),
+    legHp: new Float32Array(capacity * 2),
+    missing: new Uint16Array(capacity),
+    helmet: u8(),
+    state: u8(),
+    stateTimer: f32(),
+    lost: f32(),
+    attackTimer: f32(),
+    band: u8(),
+    next: f32(),
+    wx: f32(),
+    wz: f32(),
+    crawl: u8(),
+    limp: u8(),
+    color: new Uint32Array(capacity),
+    skin: f32(),
+    alertIn: f32(),
+    cooldown: f32(),
+    y: f32(),
+    floor: u8(),
+    floorLocked: u8(),
+    vy: f32(),
+    abilityTimer: f32(),
+    eaten: u8(),
+    stuck: f32(),
+    stepCell: new Int32Array(capacity),
+    burn: f32(),
+    hunts: new Int8Array(capacity),
+    named: new Int8Array(capacity),
+    dvx: f32(),
+    dvz: f32(),
+    steering: u8(),
+    renderYaw: f32(),
+    renderSpeed: f32(),
+    pause: f32(),
+    lod: u8(),
+    variant: u8(),
+    attackPose: u8(),
+    arms: f32()
+  };
+};
+var AGENT_FIELDS = [
+  "x",
+  "z",
+  "vx",
+  "vz",
+  "yaw",
+  "phase",
+  "type",
+  "age",
+  "outfit",
+  "height",
+  "build",
+  "chaseSpeed",
+  "wanderSpeed",
+  "hp",
+  "hpMax",
+  "headHp",
+  "missing",
+  "helmet",
+  "state",
+  "stateTimer",
+  "lost",
+  "attackTimer",
+  "band",
+  "next",
+  "wx",
+  "wz",
+  "crawl",
+  "limp",
+  "color",
+  "skin",
+  "alertIn",
+  "cooldown",
+  "y",
+  "floor",
+  "floorLocked",
+  "vy",
+  "abilityTimer",
+  "eaten",
+  "stuck",
+  "stepCell",
+  "burn",
+  "hunts",
+  "named",
+  "dvx",
+  "dvz",
+  "steering",
+  "renderYaw",
+  "renderSpeed",
+  "pause",
+  "lod",
+  "variant",
+  "attackPose",
+  "arms"
+];
+
+// src/types.ts
+var STATE = {
+  WANDER: 0,
+  CHASE: 1,
+  GRAB: 2,
+  STUNNED: 3,
+  CALLING: 4,
+  AIRBORNE: 5,
+  DORMANT: 6,
+  SWELLING: 7,
+  SWING: 8,
+  EATING: 9,
+  PILE_STEP: 10,
+  SEEKING_SOUND: 12
+};
+var MISSING = { SKULL: 1, ARM_L: 2, ARM_R: 4, LEG_L: 8, LEG_R: 16, ARM_L_BROKEN: 32, ARM_R_BROKEN: 64, LEG_L_BROKEN: 128, LEG_R_BROKEN: 256, JAW: 512 };
+
+// src/crowd.ts
+var CROWD_DEFAULTS = {
+  sources: defaults_default.sources,
+  bands: defaults_default.bands.map((band) => ({ max: band.max ?? Infinity, dt: band.dt })),
+  numbers: defaults_default.numbers
+};
+var clamp = (v, a, b) => v < a ? a : v > b ? b : v;
+var TAU_APPROX = 6.2832;
+var TURN = 6.28;
+function createCrowd(options) {
+  const random = options.random ?? createRng(options.seed ?? 1);
+  const R = random;
+  const pack = options.pack;
+  const types = pack.types;
+  const N = { ...CROWD_DEFAULTS.numbers, ...options.numbers };
+  const BANDS = options.bands ?? CROWD_DEFAULTS.bands;
+  const HYST = N.hysteresis;
+  const grid = options.grid ?? createNavGrid();
+  const doors = options.doors ?? createDoors(grid, { random });
+  const water = options.water ?? (() => false);
+  const plugins = options.plugins ?? [];
+  const clock = options.flow?.clock ?? (() => typeof performance === "undefined" ? Date.now() : performance.now());
+  const FLOW_R = options.flow?.radius ?? N.flowRadius;
+  const Z = createStore(options.capacity ?? N.capacity);
+  const { occ, occH, cellOf, solidAt } = grid;
+  const HALF = grid.half;
+  const GC = grid.cell;
+  const FW = grid.n;
+  const HC = N.hashCell;
+  const HN = Math.floor(grid.size / HC);
+  const hHead = new Int32Array(HN * HN);
+  const hNext = new Int32Array(Z.capacity);
+  const pile = new Float32Array(FW * FW);
+  let pileN = 0;
+  const flow = {
+    dir: new Int8Array(FW * FW * 2),
+    back: new Int8Array(FW * FW * 2),
+    dist: new Float32Array(FW * FW),
+    q: new Int32Array((2 * FLOW_R + 1) ** 2 * 2),
+    phase: 0,
+    qh: 0,
+    qt: 0,
+    c: 0,
+    t: 0,
+    cell: -1,
+    ms: 0,
+    win: [0, 0, -1, -1],
+    winB: [0, 0, -1, -1]
+  };
+  const catTable = [];
+  types.forEach((c, i) => {
+    for (let k = 0; k < c.weight; k++) catTable.push(i);
+  });
+  const variantsOf = [];
+  {
+    let next = 0;
+    types.forEach((type) => {
+      const list = [];
+      for (let v = 0; v < (type.variants ?? 1); v++) list.push(next++);
+      variantsOf.push(list);
+    });
+  }
+  const typeIndexById = new Map(types.map((type, index) => [type.id, index]));
+  const noises = [];
+  const stats = { bands: [0, 0, 0, 0], slots: 0, kills: 0, heads: 0 };
+  const corpses = createCorpseLedger({ max: N.corpsesMax, seconds: N.corpseSeconds });
+  const trail = [];
+  let trailLast = { x: 1e9, z: 1e9 };
+  const killQ = [];
+  let groanBudget = 0;
+  let migrateT = N.migrationFirst;
+  let hunt = null;
+  let target = options.target ?? null;
+  let nightF = 0;
+  let viewYaw = 0;
+  const listeners = /* @__PURE__ */ new Map();
+  const emit = (event, payload) => {
+    const set = listeners.get(event);
+    if (set) for (const listener of set) listener(payload);
+  };
+  const emitNoise = (x, z, r) => void noises.push({ x, z, r });
+  doors.on("noise", (e) => emitNoise(e.x, e.z, e.radius));
+  doors.on("sound", (e) => emit("sound", { ...e, distance: target ? Math.hypot(e.position[0] - target.state.x, e.position[2] - target.state.z) : 0 }));
+  doors.on("effect", (e) => emit("effect", e));
+  doors.on("broken", (e) => {
+    const d = doors.list[e.door];
+    if (target && Math.hypot(d.x - target.state.x, d.z - target.state.z) < N.doorMessageDistance) emit("message", { id: "door_broken", seconds: 2 });
+  });
+  const sound = (id, volume, x, y, z, d) => emit("sound", { sound: id, volume, position: [x, y, z], distance: d });
+  const pick = (list) => {
+    const r = R();
+    let acc = 0;
+    for (const it of list) {
+      acc += it.p;
+      if (r < acc) return it;
+    }
+    return list[0];
+  };
+  const T = (i) => types[Z.type[i]];
+  const traits = (i) => T(i).traits ?? {};
+  const special = (i) => {
+    const tr = traits(i);
+    Z.y[i] = 0;
+    Z.floor[i] = 0;
+    Z.floorLocked[i] = 0;
+    Z.vy[i] = 0;
+    Z.abilityTimer[i] = 0;
+    Z.eaten[i] = 0;
+    Z.stuck[i] = 0;
+    Z.stepCell[i] = -1;
+    Z.burn[i] = 0;
+    Z.hunts[i] = -1;
+    Z.named[i] = -1;
+    if (tr.color !== void 0 && !tr.submerged) {
+      Z.color[i] = tr.color;
+      if (tr.skin !== void 0) Z.skin[i] = tr.skin;
+    }
+    if (tr.ambush && R() < tr.ambush.chance) {
+      Z.state[i] = STATE.DORMANT;
+      Z.yaw[i] = R() * TURN;
+    }
+    if (tr.submerged) {
+      Z.state[i] = STATE.DORMANT;
+      Z.y[i] = tr.submerged.depth;
+      if (tr.color !== void 0) Z.color[i] = tr.color;
+    }
+  };
+  const spawn = (x, z, catForce = -1) => {
+    if (Z.n >= Z.capacity) return -1;
+    const i = Z.n++;
+    const c = catForce >= 0 ? catForce : catTable[Math.floor(R() * catTable.length)];
+    const C = types[c];
+    const ai = pack.ages.indexOf(pick(pack.ages));
+    const maxAge = C.traits?.maxAge;
+    const A = pack.ages[maxAge !== void 0 ? Math.min(ai, maxAge) : ai];
+    const ri = pack.outfits.indexOf(pick(pack.outfits));
+    const RO = pack.outfits[ri];
+    Z.x[i] = x;
+    Z.z[i] = z;
+    Z.vx[i] = Z.vz[i] = 0;
+    Z.type[i] = c;
+    Z.age[i] = pack.ages.indexOf(A);
+    Z.outfit[i] = ri;
+    const g = (R() + R() + R() - 1.5) * 0.09;
+    Z.height[i] = clamp(1 + g, 0.9, 1.1) * (C.scale || 1);
+    const bb = R();
+    Z.build[i] = (bb < 0.3 ? 0.85 + R() * 0.1 : bb < 0.8 ? 0.95 + R() * 0.13 : 1.08 + R() * 0.17) * (C.build || (C.scale ? 1.3 : 1));
+    const heavy = bb >= 0.8;
+    const thin = bb < 0.3;
+    Z.chaseSpeed[i] = C.speed.chase * A.speed * (thin ? 1.05 : heavy ? 0.9 : 1) * (0.92 + R() * 0.16);
+    Z.wanderSpeed[i] = C.speed.wander * A.speed * (0.8 + R() * 0.4);
+    Z.hpMax[i] = Z.hp[i] = C.health * A.health * (thin ? 0.9 : heavy ? 1.15 : 1);
+    Z.headHp[i] = pack.segments.head;
+    Z.armHp[i * 2] = Z.armHp[i * 2 + 1] = pack.segments.arm;
+    Z.legHp[i * 2] = Z.legHp[i * 2 + 1] = pack.segments.leg;
+    Z.missing[i] = 0;
+    Z.helmet[i] = RO.helmet ? 1 : 0;
+    Z.crawl[i] = C.crawls ? 1 : 0;
+    Z.limp[i] = 0;
+    Z.state[i] = 0;
+    Z.stateTimer[i] = 0;
+    Z.lost[i] = 0;
+    Z.attackTimer[i] = R();
+    Z.alertIn[i] = 0;
+    Z.cooldown[i] = 0;
+    {
+      const vs = variantsOf[c];
+      Z.variant[i] = vs[Math.floor(R() * vs.length)];
+    }
+    Z.yaw[i] = Z.renderYaw[i] = R() * TURN;
+    Z.renderSpeed[i] = 0;
+    Z.steering[i] = 0;
+    Z.pause[i] = 0;
+    Z.attackPose[i] = 0;
+    Z.arms[i] = 0;
+    Z.phase[i] = R() * 10;
+    Z.band[i] = 3;
+    Z.next[i] = R() * 0.05;
+    Z.wx[i] = x;
+    Z.wz[i] = z;
+    Z.color[i] = RO.color || pack.palette[Math.floor(R() * pack.palette.length)];
+    Z.skin[i] = R();
+    special(i);
+    emit("spawn", { agent: i, type: C.id });
+    return i;
+  };
+  const remove = (i) => {
+    if (Z.state[i] === STATE.PILE_STEP) stepRelease(i);
+    const j = --Z.n;
+    if (i === j) {
+      emit("remove", { agent: i, moved: -1 });
+      return;
+    }
+    for (const k of AGENT_FIELDS) Z[k][i] = Z[k][j];
+    Z.armHp[i * 2] = Z.armHp[j * 2];
+    Z.armHp[i * 2 + 1] = Z.armHp[j * 2 + 1];
+    Z.legHp[i * 2] = Z.legHp[j * 2];
+    Z.legHp[i * 2 + 1] = Z.legHp[j * 2 + 1];
+    if (target) {
+      if (target.state.grabbedBy === j) target.state.grabbedBy = i;
+      else if (target.state.grabbedBy === i) target.state.grabbedBy = -1;
+    }
+    emit("remove", { agent: i, moved: j });
+  };
+  const flowStart = (x, z) => {
+    const gx = clamp(Math.floor((x + HALF) / GC), 0, FW - 1);
+    const gz = clamp(Math.floor((z + HALF) / GC), 0, FW - 1);
+    const W = flow.winB;
+    W[0] = Math.max(0, gx - FLOW_R);
+    W[1] = Math.max(0, gz - FLOW_R);
+    W[2] = Math.min(FW - 1, gx + FLOW_R);
+    W[3] = Math.min(FW - 1, gz + FLOW_R);
+    for (let r = W[1]; r <= W[3]; r++) flow.dist.fill(1e9, r * FW + W[0], r * FW + W[2] + 1);
+    const s = gz * FW + gx;
+    flow.dist[s] = 0;
+    flow.q[0] = s;
+    flow.qh = 0;
+    flow.qt = 1;
+    flow.phase = 1;
+    flow.c = 0;
+    flow.t = 0;
+  };
+  const flowStep = (budget) => {
+    if (!flow.phase) return;
+    const t0 = clock();
+    const D = flow.dist;
+    const Q = flow.q;
+    const F = flow.back;
+    const W = flow.winB;
+    let n = 0;
+    while (flow.phase === 1) {
+      if (flow.qh >= flow.qt) {
+        flow.phase = 2;
+        break;
+      }
+      const c = Q[flow.qh++];
+      const cx = c % FW;
+      const cz = c / FW | 0;
+      const dc = D[c];
+      for (let dz = -1; dz <= 1; dz++)
+        for (let dx = -1; dx <= 1; dx++) {
+          if (!dx && !dz) continue;
+          const nx = cx + dx;
+          const nz = cz + dz;
+          if (nx < W[0] || nz < W[1] || nx > W[2] || nz > W[3]) continue;
+          const k = nz * FW + nx;
+          if (occ[k] && occ[k] < 3) continue;
+          if (dx && dz && (occ[cz * FW + nx] && occ[cz * FW + nx] < 3 || occ[nz * FW + cx] && occ[nz * FW + cx] < 3)) continue;
+          const nd = dc + (dx && dz ? 1.414 : 1);
+          if (nd < D[k] - 1e-3) {
+            D[k] = nd;
+            if (flow.qt < Q.length) Q[flow.qt++] = k;
+          }
+        }
+      if ((++n & 2047) === 0 && clock() - t0 > budget) {
+        flow.t += clock() - t0;
+        return;
+      }
+    }
+    const ww = W[2] - W[0] + 1;
+    while (flow.phase === 2) {
+      const j = flow.c++;
+      if (j >= ww * (W[3] - W[1] + 1)) {
+        const tmp = flow.dir;
+        flow.dir = F;
+        flow.back = tmp;
+        const tw = flow.win;
+        flow.win = W;
+        flow.winB = tw;
+        flow.phase = 0;
+        flow.ms = flow.t + clock() - t0;
+        return;
+      }
+      const cx = W[0] + j % ww;
+      const cz = W[1] + (j / ww | 0);
+      const c = cz * FW + cx;
+      if (occ[c] && occ[c] < 3) {
+        F[c * 2] = F[c * 2 + 1] = 0;
+        continue;
+      }
+      let best = D[c];
+      let bx = 0;
+      let bz = 0;
+      for (let dz = -1; dz <= 1; dz++)
+        for (let dx = -1; dx <= 1; dx++) {
+          const nx = cx + dx;
+          const nz = cz + dz;
+          if (nx < W[0] || nz < W[1] || nx > W[2] || nz > W[3]) continue;
+          const d = D[nz * FW + nx];
+          if (d < best) {
+            best = d;
+            bx = dx;
+            bz = dz;
+          }
+        }
+      F[c * 2] = bx;
+      F[c * 2 + 1] = bz;
+      if ((j & 8191) === 0 && clock() - t0 > budget) {
+        flow.t += clock() - t0;
+        return;
+      }
+    }
+  };
+  const losClear = grid.losClear;
+  const groundAt = (c, _y) => {
+    if (c < 0) return 0;
+    const k = occ[c];
+    if (k === 2 || k === 1 && occH[c] <= _y + 0.05) return occH[c];
+    return pile[c];
+  };
+  const blockedAt = (i, x, z) => {
+    const c = cellOf(x, z);
+    if (c < 0) return true;
+    const k = occ[c];
+    const y = Z.y[i];
+    if (k === 0 || k === 3) return pile[c] > y + 0.5 && Z.state[i] !== STATE.AIRBORNE;
+    if (k === 2 && y + 0.5 >= occH[c]) return false;
+    if (Z.state[i] === STATE.AIRBORNE && occH[c] <= y) return false;
+    return true;
+  };
+  const tryStep = (i, hitCell) => {
+    if (pileN >= N.pileMax) return false;
+    const c = cellOf(Z.x[i], Z.z[i]);
+    if (c < 0 || occ[c] !== 0) return false;
+    const dir = hitCell - c;
+    const w = c + dir;
+    const back = c - dir;
+    const h = pile[c] + N.pileStep;
+    if (h > N.pileTop) return false;
+    const cap = occ[w] === 2 ? (back >= 0 ? pile[back] : 0) + 1 : pile[w];
+    if (h > cap + 1e-3) return false;
+    pile[c] = h;
+    pileN++;
+    Z.state[i] = STATE.PILE_STEP;
+    Z.stepCell[i] = c;
+    Z.vx[i] = Z.vz[i] = 0;
+    Z.y[i] = h - N.pileStep;
+    Z.stateTimer[i] = 6 + R() * 6;
+    return true;
+  };
+  function stepRelease(i) {
+    const c = Z.stepCell[i];
+    if (c >= 0) {
+      pile[c] = Math.max(0, pile[c] - N.pileStep);
+      pileN = Math.max(0, pileN - 1);
+    }
+    Z.stepCell[i] = -1;
+    Z.state[i] = STATE.CHASE;
+    Z.stuck[i] = 0;
+  }
+  const pileBlast = (x, z, r) => {
+    for (let i = 0; i < Z.n; i++)
+      if (Z.state[i] === STATE.PILE_STEP && (Z.x[i] - x) ** 2 + (Z.z[i] - z) ** 2 < r * r) {
+        stepRelease(i);
+        Z.state[i] = STATE.STUNNED;
+        Z.stateTimer[i] = 1.2;
+      }
+  };
+  const voice = (i) => traits(i).voice ?? "groan";
+  const groan = (i, d) => {
+    const r2 = N.alertRadius * N.alertRadius;
+    for (let j = 0; j < Z.n; j++) {
+      if (Z.state[j] !== 0 || Z.alertIn[j] > 0) continue;
+      const ex = Z.x[j] - Z.x[i];
+      const ez = Z.z[j] - Z.z[i];
+      if (ex * ex + ez * ez < r2) Z.alertIn[j] = N.alertDelay + R() * N.alertDelayRandom;
+    }
+    emit("alert", { agent: i });
+    if (d < N.voiceDistance && groanBudget <= 0) {
+      sound(voice(i), 1, Z.x[i], Z.height[i] * 1.6, Z.z[i], d);
+      groanBudget = N.voiceEvery;
+    }
+  };
+  const screamAt = (i, x, z) => {
+    const tr = traits(i).caller;
+    sound("scream_hoarse", 1, x, 1.6, z, target ? Math.hypot(x - target.state.x, z - target.state.z) : 0);
+    for (let j = 0; j < Z.n; j++) {
+      const ex = Z.x[j] - x;
+      const ez = Z.z[j] - z;
+      if (ex * ex + ez * ez < tr.radius * tr.radius) {
+        Z.state[j] = STATE.CHASE;
+        Z.lost[j] = 0;
+      }
+    }
+    if (target) target.state.screamBoost = tr.boost;
+    emit("message", { id: "called", seconds: 3, type: T(i).id });
+    emit("scream", { agent: i, x, z });
+  };
+  const attack = (i, d, tdt) => {
+    Z.attackTimer[i] -= tdt;
+    if (Z.attackTimer[i] > 0) return;
+    Z.attackTimer[i] = N.attackEvery;
+    const C = T(i);
+    const tr = C.traits ?? {};
+    if (tr.heavySwing && R() < tr.heavySwing.chance) {
+      Z.state[i] = STATE.SWING;
+      Z.stateTimer[i] = tr.heavySwing.windUp;
+      return;
+    }
+    const noJaw = Z.missing[i] & 512;
+    const noArms = (Z.missing[i] & 6) === 6;
+    const P = target;
+    if (P.state.grabbedBy < 0 && !noArms && !Z.crawl[i] && R() < C.bite * (P.state.crouch ? N.crouchBite : 1)) {
+      P.grab(i, !!noJaw, !!tr.drownGrab && water(P.state.x, P.state.z));
+      Z.state[i] = STATE.GRAB;
+    } else {
+      P.hurt(C.damage * (Z.crawl[i] ? N.crawlDamage : 1), i);
+      if (tr.burns && Z.abilityTimer[i] >= 0) P.state.burnTimer = tr.burns.seconds;
+    }
+    void d;
+  };
+  const effect = (payload) => emit("effect", payload);
+  const blood = (x, y, z, age, amount, died, agent) => effect({ effect: "blood", point: [x, y, z], age, amount, died, ...agent === void 0 ? {} : { agent } });
+  const damage = (i, hit) => {
+    const C = T(i);
+    const A = pack.ages[Z.age[i]];
+    const RO = pack.outfits[Z.outfit[i]];
+    const cal = hit.caliber ?? null;
+    const proj = !!cal;
+    const dano = hit.amount;
+    const dist = hit.distance;
+    const corte = hit.cut ?? 0;
+    const regiao = hit.region;
+    let morreu = false;
+    let headshot = false;
+    if (regiao === 0) {
+      if (proj && Z.helmet[i] && cal.class === "pistol") {
+        Z.helmet[i] = 0;
+        effect({ effect: "spark", point: [Z.x[i], Z.height[i] * 1.75, Z.z[i]], agent: i });
+        sound("impact", 1, Z.x[i], Z.height[i] * 1.75, Z.z[i], dist);
+        return { died: false };
+      }
+      const mata = proj ? (cal.skull === 1 || dist <= cal.skull) && dano >= N.skullMinDamage : dano * 3 >= Z.headHp[i];
+      if (mata) {
+        morreu = true;
+        headshot = true;
+        if (dano > N.skullTakeDamage || cal && N.skullTakeWithin[cal.id] !== void 0 && dist < N.skullTakeWithin[cal.id]) Z.missing[i] |= 1;
+      } else {
+        Z.hp[i] -= dano * 3;
+        Z.headHp[i] -= dano;
+        if (dano > N.jawDamage && R() < N.jawChance) Z.missing[i] |= 512;
+      }
+    } else if (regiao === 1) {
+      let m = C.multipliers.torso;
+      if (RO.vest && proj) m *= cal.class === "pistol" ? RO.vest.pistol : RO.vest.rifle;
+      Z.hp[i] -= dano * m;
+    } else {
+      const perna = regiao >= 4;
+      const lado = regiao & 1;
+      const mm = (perna ? C.multipliers.legs : C.multipliers.arms) * A.limb * (RO.limb || 1);
+      const segArr = perna ? Z.legHp : Z.armHp;
+      const k = i * 2 + (perna ? lado : regiao === 3 ? 1 : 0);
+      segArr[k] -= dano * mm;
+      Z.hp[i] -= dano * mm * 0.5;
+      const max = perna ? pack.segments.leg : pack.segments.arm;
+      if (perna && segArr[k] <= max * 0.5) Z.limp[i] = 1;
+      if (segArr[k] <= 0) {
+        const arranca = corte >= 0.5 || dano * mm > max * 0.9;
+        if (perna) {
+          Z.crawl[i] = 1;
+          if (arranca) Z.missing[i] |= lado ? 16 : 8;
+          else Z.missing[i] |= lado ? 256 : 128;
+        } else if (arranca) Z.missing[i] |= regiao === 3 ? 4 : 2;
+        else Z.missing[i] |= regiao === 3 ? 64 : 32;
+        effect({ effect: "limb", point: [Z.x[i], Z.height[i] * (perna ? 0.5 : 1.2), Z.z[i]], agent: i, region: regiao, severed: arranca });
+      }
+    }
+    if (Z.hp[i] <= 0) morreu = true;
+    blood(Z.x[i], regiao === 0 ? Z.height[i] * 1.65 : regiao === 1 ? Z.height[i] * 1.2 : Z.height[i] * 0.7, Z.z[i], Z.age[i], regiao === 0 ? 120 : 30, morreu, i);
+    if (morreu) {
+      kill(i, headshot);
+      return { died: morreu, headshot };
+    }
+    const st = Z.state[i];
+    if (dano >= N.hitStunDamage && st !== STATE.GRAB && st !== STATE.PILE_STEP && st !== STATE.AIRBORNE) {
+      Z.state[i] = STATE.STUNNED;
+      Z.stateTimer[i] = C.traits?.hitStun ?? N.hitStun;
+    }
+    const st2 = Z.state[i];
+    if (st2 === 0 || st2 === STATE.DORMANT || st2 === STATE.EATING || st2 === STATE.SEEKING_SOUND) {
+      Z.state[i] = STATE.CHASE;
+      Z.lost[i] = 0;
+      const sub = C.traits?.submerged;
+      if (sub) Z.y[i] = Math.max(Z.y[i], sub.surface);
+    }
+    return { died: morreu };
+  };
+  function kill(i, headshot = false) {
+    stats.kills++;
+    if (headshot) stats.heads++;
+    const tr = traits(i);
+    if (tr.burst) burstAt(i, Z.x[i], Z.z[i]);
+    const C = T(i);
+    emit("kill", { agent: i, type: C.id, headshot, x: Z.x[i], z: Z.z[i] });
+    corpseAdd(i);
+    if (target && target.state.grabbedBy === i) target.release();
+    remove(i);
+  }
+  const burstAt = (i, x, z) => {
+    const b = traits(i).burst;
+    effect({ effect: "cloud", point: [x, 0, z], radius: 4, color: b.cloudColor, amount: 8 });
+    effect({ effect: "blood", point: [x, 1, z], amount: 1500, died: true, color: b.bloodColor });
+    if (target) {
+      const d = Math.hypot(x - target.state.x, z - target.state.z);
+      if (d < b.radius) {
+        target.state.blind = b.blind;
+        target.state.scentTimer = b.scent;
+        emit("message", { id: "burst_hit", seconds: 2.5, type: T(i).id });
+        emitNoise(target.state.x, target.state.z, b.noiseNear);
+      }
+    }
+    emitNoise(x, z, b.noise);
+  };
+  const corpseAdd = (i) => {
+    corpses.add({
+      x: Z.x[i],
+      z: Z.z[i],
+      yaw: Z.renderYaw[i],
+      height: Z.height[i],
+      build: Z.build[i],
+      named: Z.named[i],
+      missing: Z.missing[i],
+      color: Z.color[i],
+      variant: Z.variant[i],
+      skin: Z.skin[i],
+      seed: R() * 10
+    });
+  };
+  const ability = (i, d, dx, dz, tdt, b, alive) => {
+    const C = T(i);
+    const tr = C.traits ?? {};
+    const st = Z.state[i];
+    const P = target;
+    if (st === STATE.DORMANT) {
+      Z.vx[i] = Z.vz[i] = 0;
+      if (!alive || b > 1) return true;
+      if (tr.submerged) {
+        if (d < tr.submerged.wake) {
+          Z.state[i] = STATE.CHASE;
+          groan(i, d);
+          sound("step", 2, Z.x[i], 0, Z.z[i], d);
+        }
+        return true;
+      }
+      const am = tr.ambush;
+      const wake = am?.wake ?? N.dormantWake;
+      const behind = am?.wakeBehind ?? N.dormantWakeBehind;
+      const fx = -Math.sin(viewYaw);
+      const fz = -Math.cos(viewYaw);
+      const costas = (dx * fx + dz * fz) / (d || 1) < (am?.behindCos ?? -0.3);
+      if (d < wake || costas && d < behind) {
+        Z.state[i] = STATE.CHASE;
+        Z.abilityTimer[i] = am?.sprintSeconds ?? 3;
+        Z.lost[i] = 0;
+        sound("runner_groan", 1, Z.x[i], 1.6, Z.z[i], d);
+      }
+      return true;
+    }
+    if (st === STATE.AIRBORNE || st === STATE.PILE_STEP) return true;
+    if (st === STATE.SWELLING) {
+      Z.vx[i] = Z.vz[i] = 0;
+      return true;
+    }
+    if (st === STATE.SWING) {
+      Z.vx[i] = Z.vz[i] = 0;
+      Z.stateTimer[i] -= tdt;
+      if (Z.stateTimer[i] <= 0) {
+        const hs = tr.heavySwing;
+        Z.state[i] = STATE.CHASE;
+        Z.attackTimer[i] = 2;
+        sound("impact", 1.4, Z.x[i], 1, Z.z[i], d);
+        if (d < hs.range && alive && P) {
+          P.hurt(C.damage, i);
+          P.knock(hs.knock);
+          emit("message", { id: "swing_knock", seconds: 1.5, type: C.id });
+        }
+      }
+      return true;
+    }
+    if (st === STATE.EATING) {
+      const ec2 = tr.eatsCorpses;
+      Z.vx[i] = Z.vz[i] = 0;
+      Z.stateTimer[i] -= tdt;
+      if (alive && d < ec2.defend) {
+        Z.state[i] = STATE.CHASE;
+        Z.lost[i] = 0;
+        groan(i, d);
+        return false;
+      }
+      if (Z.stateTimer[i] <= 0) {
+        let best = -1;
+        let bd = ec2.grabRange;
+        const list = corpses.entries;
+        for (let k = 0; k < list.length; k++) {
+          const e = Math.hypot(list[k].data.x - Z.x[i], list[k].data.z - Z.z[i]);
+          if (e < bd) {
+            bd = e;
+            best = k;
+          }
+        }
+        if (best >= 0) {
+          corpses.remove(best);
+          Z.hp[i] += ec2.health;
+          Z.hpMax[i] += ec2.health;
+          Z.height[i] *= ec2.grow;
+          Z.build[i] *= ec2.grow;
+          Z.eaten[i]++;
+        }
+        Z.state[i] = 0;
+        Z.abilityTimer[i] = ec2.rest;
+      }
+      return true;
+    }
+    if (st === STATE.SEEKING_SOUND) {
+      const ss = tr.soundSeeker ?? { arrive: 1, loseChase: 3, hitRadius2: 1.1 };
+      if (alive && d < 2.5) {
+        Z.state[i] = STATE.CHASE;
+        return false;
+      }
+      const wx = Z.wx[i] - Z.x[i];
+      const wz = Z.wz[i] - Z.z[i];
+      const wl = Math.hypot(wx, wz);
+      if (wl < ss.arrive) {
+        Z.state[i] = 0;
+        return false;
+      }
+      Z.vx[i] = wx / wl * Z.chaseSpeed[i];
+      Z.vz[i] = wz / wl * Z.chaseSpeed[i];
+      Z.yaw[i] = Math.atan2(wx, wz);
+      if (b === 0) {
+        Z.attackTimer[i] -= tdt;
+        if (Z.attackTimer[i] <= 0) {
+          const hx = Math.floor(Z.x[i] + HALF);
+          const hz = Math.floor(Z.z[i] + HALF);
+          if (hx >= 0 && hz >= 0 && hx < HN && hz < HN)
+            for (let j = hHead[hz * HN + hx]; j !== -1; j = hNext[j]) {
+              if (j !== i && (Z.x[j] - Z.x[i]) ** 2 + (Z.z[j] - Z.z[i]) ** 2 < ss.hitRadius2) {
+                Z.attackTimer[i] = N.attackEvery;
+                hurtOther(j, C.damage);
+                break;
+              }
+            }
+        }
+      }
+      return true;
+    }
+    for (const plugin of plugins) if (plugin.ability?.(crowd, i, { d, dx, dz, tdt, band: b, alive })) return true;
+    if (!alive) return false;
+    if (Z.hunts[i] >= 0 && st <= 1 && hunt) return hunt(i, tdt);
+    if (tr.soundSeeker && st === STATE.CHASE && d > tr.soundSeeker.loseChase) {
+      Z.state[i] = STATE.SEEKING_SOUND;
+      Z.wx[i] = P.state.x;
+      Z.wz[i] = P.state.z;
+      return false;
+    }
+    const po = tr.pounce;
+    if (po && st === STATE.CHASE && Z.cooldown[i] <= 0 && d > po.min && d < po.max && b === 0 && losClear(Z.x[i], Z.z[i], P.state.x, P.state.z)) {
+      const sp = Math.min(po.speedCap, d / po.time);
+      Z.state[i] = STATE.AIRBORNE;
+      Z.vy[i] = P.state.y > po.highAbove ? po.liftHigh : po.lift;
+      Z.vx[i] = -dx / d * sp;
+      Z.vz[i] = -dz / d * sp;
+      Z.yaw[i] = Math.atan2(-dx, -dz);
+      Z.cooldown[i] = po.cooldown;
+      Z.abilityTimer[i] = 1;
+      sound("runner_groan", 1, Z.x[i], 1.6, Z.z[i], d);
+      return true;
+    }
+    if (tr.burst && st === STATE.CHASE && d < tr.burst.range) {
+      Z.state[i] = STATE.SWELLING;
+      Z.stateTimer[i] = tr.burst.swell;
+      sound("flesh", 1.2, Z.x[i], 1, Z.z[i], d);
+      return true;
+    }
+    const ec = tr.eatsCorpses;
+    if (ec && st === 0 && Z.eaten[i] < ec.max && Z.abilityTimer[i] <= 0 && corpses.count) {
+      let best = -1;
+      let bd = ec.search;
+      const list = corpses.entries;
+      for (let k = 0; k < list.length; k++) {
+        const e = Math.hypot(list[k].data.x - Z.x[i], list[k].data.z - Z.z[i]);
+        if (e < bd) {
+          bd = e;
+          best = k;
+        }
+      }
+      if (best >= 0) {
+        if (bd < ec.reach) {
+          Z.state[i] = STATE.EATING;
+          Z.stateTimer[i] = ec.seconds;
+          Z.vx[i] = Z.vz[i] = 0;
+          return true;
+        }
+        const cp = list[best].data;
+        const ex = cp.x - Z.x[i];
+        const ez = cp.z - Z.z[i];
+        const sp = Z.wanderSpeed[i] * ec.approach;
+        Z.vx[i] = ex / bd * sp;
+        Z.vz[i] = ez / bd * sp;
+        Z.yaw[i] = Math.atan2(ex, ez);
+        Z.wx[i] = cp.x;
+        Z.wz[i] = cp.z;
+        return true;
+      } else Z.abilityTimer[i] = ec.retry;
+    }
+    const tk = tr.tracker;
+    if (tk && st === 0 && trail.length) {
+      let best = null;
+      for (let k = trail.length - 1; k >= 0; k--) {
+        const p = trail[k];
+        if ((p.x - Z.x[i]) ** 2 + (p.z - Z.z[i]) ** 2 < tk.range * tk.range) {
+          best = p;
+          break;
+        }
+      }
+      if (best) {
+        Z.wx[i] = best.x;
+        Z.wz[i] = best.z;
+        let led = 0;
+        const leads = typeIndexById.get(tk.leads) ?? -1;
+        for (let j = 0; j < Z.n && led < tk.max; j++)
+          if (Z.type[j] === leads && Z.state[j] === 0 && (Z.x[j] - Z.x[i]) ** 2 + (Z.z[j] - Z.z[i]) ** 2 < tk.leadRadius * tk.leadRadius) {
+            Z.wx[j] = Z.x[i];
+            Z.wz[j] = Z.z[i];
+            led++;
+          }
+      }
+    }
+    return false;
+  };
+  const chaseSpeed = (i) => {
+    const tr = traits(i);
+    if (tr.ambush) return Z.abilityTimer[i] > 0 ? tr.ambush.sprint : tr.ambush.slow;
+    if (tr.submerged && water(Z.x[i], Z.z[i])) return tr.submerged.swim;
+    return Z.chaseSpeed[i];
+  };
+  const hurtOther = (j, amount) => {
+    Z.hp[j] -= amount;
+    blood(Z.x[j], Z.height[j] * 1.2, Z.z[j], Z.age[j], 30, false, j);
+    if (Z.hp[j] <= 0) deferKill(j);
+  };
+  const deferKill = (j) => {
+    if (!killQ.includes(j)) killQ.push(j);
+  };
+  const killQFlush = () => {
+    if (!killQ.length) return;
+    killQ.sort((a, b) => b - a);
+    for (const j of killQ) if (j < Z.n) kill(j, false);
+    killQ.length = 0;
+  };
+  const frame = (i, dt, d, alive) => {
+    const st = Z.state[i];
+    const tr = traits(i);
+    if (st === STATE.PILE_STEP) {
+      Z.stateTimer[i] -= dt;
+      if (!alive || d > N.pileReleaseDistance || Z.stateTimer[i] <= 0) stepRelease(i);
+      return;
+    }
+    if (st === STATE.SWELLING) {
+      Z.stateTimer[i] -= dt;
+      if (Z.stateTimer[i] <= 0) deferKill(i);
+      return;
+    }
+    if (tr.ambush && Z.abilityTimer[i] > 0) Z.abilityTimer[i] -= dt;
+    if (tr.eatsCorpses && Z.abilityTimer[i] > 0 && st === 0) Z.abilityTimer[i] -= dt;
+    if (tr.waterWeak && Z.abilityTimer[i] === 0 && water(Z.x[i], Z.z[i])) {
+      Z.abilityTimer[i] = -1;
+      Z.hp[i] *= tr.waterWeak.keep;
+      effect({ effect: "cloud", point: [Z.x[i], 0, Z.z[i]], radius: 1.5, color: tr.waterWeak.cloud, amount: 3, agent: i });
+    }
+    const c = cellOf(Z.x[i], Z.z[i]);
+    const gy = groundAt(c, Z.y[i]);
+    if (st === STATE.DORMANT || Z.floorLocked[i]) return;
+    if (st === STATE.AIRBORNE || Z.y[i] > gy + 0.02 || Z.vy[i] > 0) {
+      Z.vy[i] -= N.gravity * dt;
+      Z.y[i] += Z.vy[i] * dt;
+      if (Z.y[i] <= gy) {
+        const fall = -Z.vy[i];
+        Z.y[i] = gy;
+        Z.vy[i] = 0;
+        if (st === STATE.AIRBORNE) {
+          Z.state[i] = STATE.CHASE;
+          if (tr.pounce && alive && d < tr.pounce.landRange && target) {
+            target.knock(tr.pounce.knock);
+            target.hurt(T(i).damage, i);
+            emit("message", { id: "pounce_knock", seconds: 1.5, type: T(i).id });
+          }
+        } else if (fall > N.fallStun && Z.state[i] <= 1) {
+          Z.state[i] = STATE.STUNNED;
+          Z.stateTimer[i] = 0.9;
+        }
+      }
+    } else if (gy > Z.y[i]) Z.y[i] = Math.min(gy, Z.y[i] + N.climbSpeed * dt);
+  };
+  const update = (dt, context = {}) => {
+    if (context.target !== void 0) target = context.target;
+    groanBudget -= dt;
+    nightF = context.nightFactor ?? 0;
+    const P = target;
+    const px = P ? P.state.x : context.flowTarget?.[0] ?? 0;
+    const pz = P ? P.state.z : context.flowTarget?.[1] ?? 0;
+    const alive = !!P && P.state.alive && !P.state.turned;
+    viewYaw = context.viewYaw ?? (P ? P.state.yaw - Math.PI : 0);
+    const fx0 = context.flowTarget?.[0] ?? px;
+    const fz0 = context.flowTarget?.[1] ?? pz;
+    const pc = cellOf(fx0, fz0);
+    if (flow.cell < 0) {
+      flowStart(fx0, fz0);
+      flowStep(1e9);
+      flow.cell = pc;
+    } else if (pc !== flow.cell && !flow.phase) {
+      flowStart(fx0, fz0);
+      flow.cell = pc;
+    }
+    flowStep(N.flowBudgetMs);
+    hHead.fill(-1);
+    for (let i = 0; i < Z.n; i++) {
+      if (Z.band[i] !== 0) continue;
+      const hx = Math.floor(Z.x[i] + HALF);
+      const hz = Math.floor(Z.z[i] + HALF);
+      if (hx < 0 || hz < 0 || hx >= HN || hz >= HN) continue;
+      const h = hz * HN + hx;
+      hNext[i] = hHead[h];
+      hHead[h] = i;
+    }
+    const B = stats.bands;
+    B[0] = B[1] = B[2] = B[3] = 0;
+    let slots = 0;
+    const F = flow.dir;
+    for (let i = 0; i < Z.n; i++) {
+      const dx = Z.x[i] - px;
+      const dz = Z.z[i] - pz;
+      const d = Math.sqrt(dx * dx + dz * dz);
+      let b = Z.band[i];
+      while (b > 0 && d < BANDS[b - 1].max - HYST) b--;
+      while (b < 3 && d > BANDS[b].max + HYST) b++;
+      Z.band[i] = b;
+      B[b]++;
+      const C = T(i);
+      const tr = C.traits ?? {};
+      if (Z.state[i] === STATE.STUNNED) {
+        Z.stateTimer[i] -= dt;
+        if (Z.stateTimer[i] <= 0) Z.state[i] = STATE.CHASE;
+        Z.vx[i] *= 0.9;
+        Z.vz[i] *= 0.9;
+      }
+      if (Z.state[i] === STATE.CALLING) {
+        Z.stateTimer[i] -= dt;
+        Z.vx[i] = Z.vz[i] = 0;
+        if (Z.stateTimer[i] <= 0) {
+          Z.state[i] = STATE.CHASE;
+          screamAt(i, Z.x[i], Z.z[i]);
+          Z.cooldown[i] = tr.caller.cooldown;
+        }
+      }
+      Z.cooldown[i] -= dt;
+      if (Z.alertIn[i] > 0) {
+        Z.alertIn[i] -= dt;
+        if (Z.alertIn[i] <= 0 && Z.state[i] === 0 && !tr.soundSeeker) {
+          Z.state[i] = STATE.CHASE;
+          Z.lost[i] = 0;
+        }
+      }
+      Z.next[i] -= dt;
+      if (Z.next[i] <= 0) {
+        const tdt = BANDS[b].dt;
+        Z.next[i] += tdt;
+        if (alive && b <= 1 && Z.state[i] <= 1) {
+          let sees = false;
+          const A = pack.ages[Z.age[i]];
+          const vis = C.perception.sight * (1 - N.nightSight * nightF) * (P.state.crouch ? N.crouchSight : 1) * A.sight;
+          if (d < vis) {
+            const fx = Math.sin(Z.yaw[i]);
+            const fz = Math.cos(Z.yaw[i]);
+            const cone = (-dx * fx - dz * fz) / (d || 1);
+            if ((cone > N.sightCone || d < N.sightNear) && (Z.floor[i] === P.state.floor || d < 5) && (Z.floor[i] || P.state.floor || losClear(Z.x[i], Z.z[i], px, pz))) sees = true;
+          }
+          if (C.perception.smell && d < C.perception.smell * (P.state.bleeding || P.state.scentTimer > 0 ? 2 : 1)) sees = true;
+          if (sees) {
+            if (Z.state[i] === 0) groan(i, d);
+            Z.state[i] = STATE.CHASE;
+            Z.lost[i] = 0;
+          } else if (Z.state[i] === STATE.CHASE) {
+            Z.lost[i] += tdt;
+            if (Z.lost[i] > N.loseAfter) {
+              Z.state[i] = 0;
+              Z.wx[i] = px;
+              Z.wz[i] = pz;
+            }
+          }
+        }
+        for (let k = 0; k < noises.length && (Z.state[i] === 0 || Z.state[i] === STATE.SEEKING_SOUND); k++) {
+          const Nz = noises[k];
+          const hear = Nz.r * (C.perception.hearing / N.hearingBase) * pack.ages[Z.age[i]].hearing;
+          if ((Z.x[i] - Nz.x) ** 2 + (Z.z[i] - Nz.z) ** 2 < hear * hear) {
+            if (tr.soundSeeker) {
+              Z.state[i] = STATE.SEEKING_SOUND;
+              Z.wx[i] = Nz.x;
+              Z.wz[i] = Nz.z;
+              break;
+            }
+            Z.state[i] = STATE.CHASE;
+            Z.lost[i] = N.heardLost;
+            groan(i, d);
+          }
+        }
+        if (tr.caller && Z.state[i] === STATE.CHASE && d < tr.caller.range && Z.cooldown[i] <= 0) {
+          Z.state[i] = STATE.CALLING;
+          Z.stateTimer[i] = tr.caller.windUp;
+        }
+        Z.steering[i] = 0;
+        if (!ability(i, d, dx, dz, tdt, b, alive)) {
+          let tx = 0;
+          let tz = 0;
+          let sp = 0;
+          if (Z.state[i] === STATE.CHASE || Z.state[i] === STATE.GRAB) {
+            const c = cellOf(Z.x[i], Z.z[i]);
+            const sameL = !P || Z.floor[i] === P.state.floor;
+            if (d < N.directRange && alive && sameL) {
+              tx = -dx / (d || 1);
+              tz = -dz / (d || 1);
+            } else if (c >= 0 && b === 0 && d < N.pyramidRange && sameL && flow.dist[c] < 1e8 && flow.dist[c] * GC > d * 2 + 6 && losClear(Z.x[i], Z.z[i], px, pz)) {
+              tx = -dx / d;
+              tz = -dz / d;
+            } else if (c >= 0) {
+              const W = flow.win;
+              const cx = c % FW;
+              const cz = c / FW | 0;
+              if (cx >= W[0] && cx <= W[2] && cz >= W[1] && cz <= W[3]) {
+                tx = F[c * 2];
+                tz = F[c * 2 + 1];
+              } else {
+                tx = -dx;
+                tz = -dz;
+              }
+              const l = Math.hypot(tx, tz) || 1;
+              tx /= l;
+              tz /= l;
+            }
+            if (tr.caller && Z.cooldown[i] > tr.caller.fleeAbove && d < tr.caller.fleeRange && alive) {
+              tx = dx / (d || 1);
+              tz = dz / (d || 1);
+            }
+            sp = chaseSpeed(i) * (P && P.state.screamBoost > 0 ? N.screamSpeed : 1);
+            if (!alive) sp = Z.wanderSpeed[i];
+            if (d < N.attackRange && alive && Math.abs(P.state.y - Z.y[i]) < N.attackHeight) {
+              sp = 0;
+              if (slots < N.attackSlots) {
+                slots++;
+                attack(i, d, tdt);
+              }
+            }
+          } else if (Z.state[i] === 0) {
+            const wx = Z.wx[i] - Z.x[i];
+            const wz = Z.wz[i] - Z.z[i];
+            const wl = Math.hypot(wx, wz);
+            if (wl < 1 || R() < 0.01 * tdt * 60) {
+              Z.wx[i] = clamp(Z.x[i] + (R() - 0.5) * N.wanderSpan, -HALF + 2, HALF - 2);
+              Z.wz[i] = clamp(Z.z[i] + (R() - 0.5) * N.wanderSpan, -HALF + 2, HALF - 2);
+            } else {
+              tx = wx / wl;
+              tz = wz / wl;
+              Z.pause[i] -= tdt;
+              if (Z.pause[i] < -4 - R() * 6) Z.pause[i] = 1 + R() * 2.5;
+              sp = Z.pause[i] > 0 ? 0 : Z.wanderSpeed[i];
+            }
+          }
+          if (Z.crawl[i]) sp = Math.min(sp, N.crawlSpeed);
+          else if (Z.limp[i]) sp *= N.limpSpeed;
+          let sx = 0;
+          let sz = 0;
+          if (b === 0) {
+            const hx = Math.floor(Z.x[i] + HALF);
+            const hz = Math.floor(Z.z[i] + HALF);
+            for (let oz = -1; oz <= 1; oz++)
+              for (let ox = -1; ox <= 1; ox++) {
+                const qx = hx + ox;
+                const qz = hz + oz;
+                if (qx < 0 || qz < 0 || qx >= HN || qz >= HN) continue;
+                for (let j = hHead[qz * HN + qx]; j !== -1; j = hNext[j]) {
+                  if (j === i || Z.state[j] === STATE.PILE_STEP || Z.state[j] === STATE.DORMANT) continue;
+                  const ex = Z.x[i] - Z.x[j];
+                  const ez = Z.z[i] - Z.z[j];
+                  const e2 = ex * ex + ez * ez;
+                  const rr = N.separation * (Z.build[i] + Z.build[j]);
+                  if (e2 < rr * rr * 1.6 && e2 > 1e-6) {
+                    const e = Math.sqrt(e2);
+                    const w = (rr * 1.26 - e) / e;
+                    sx += ex * w;
+                    sz += ez * w;
+                  }
+                }
+              }
+          }
+          if (Z.state[i] <= 2) {
+            Z.dvx[i] = tx * sp + sx * N.separationPush;
+            Z.dvz[i] = tz * sp + sz * N.separationPush;
+            Z.steering[i] = 1;
+            if (sp > 0.05) Z.yaw[i] = Math.atan2(tx, tz);
+            else if (d < 3 && alive) Z.yaw[i] = Math.atan2(-dx, -dz);
+          }
+        }
+      }
+      if (Z.steering[i] && Z.state[i] <= 2) {
+        const k = 1 - Math.exp(-dt * (b === 0 ? 9 : 5));
+        Z.vx[i] += (Z.dvx[i] - Z.vx[i]) * k;
+        Z.vz[i] += (Z.dvz[i] - Z.vz[i]) * k;
+      }
+      const nx = Z.x[i] + Z.vx[i] * dt;
+      const nz = Z.z[i] + Z.vz[i] * dt;
+      let hitCell = -1;
+      if (!blockedAt(i, nx, Z.z[i])) Z.x[i] = nx;
+      else {
+        if (Z.state[i] !== STATE.AIRBORNE) Z.vx[i] = 0;
+        hitCell = cellOf(nx, Z.z[i]);
+      }
+      if (!blockedAt(i, Z.x[i], nz)) Z.z[i] = nz;
+      else {
+        if (Z.state[i] !== STATE.AIRBORNE) Z.vz[i] = 0;
+        hitCell = cellOf(Z.x[i], nz);
+      }
+      if (hitCell >= 0 && Z.state[i] === STATE.CHASE && b === 0) {
+        const vl = tr.vaultsLow;
+        if (vl && occ[hitCell] !== 5 && occH[hitCell] <= vl.maxHeight && occH[hitCell] > Z.y[i] + vl.minRise) {
+          Z.state[i] = STATE.AIRBORNE;
+          Z.vy[i] = Math.sqrt(2 * N.gravity * (occH[hitCell] - Z.y[i] + vl.clearance));
+          const s2 = Z.chaseSpeed[i] * vl.speedFactor;
+          Z.vx[i] = Math.sin(Z.yaw[i]) * s2;
+          Z.vz[i] = Math.cos(Z.yaw[i]) * s2;
+        } else if (occ[hitCell] === 2 || occ[hitCell] === 0 && pile[hitCell] > 0) {
+          Z.stuck[i] += dt;
+          if (Z.stuck[i] > 0.35 + 0.5 * Z.skin[i]) {
+            Z.stuck[i] = 0;
+            tryStep(i, hitCell);
+          }
+        }
+      } else if (Z.stuck[i] > 0) Z.stuck[i] -= dt;
+      if (hitCell >= 0 && Z.state[i] === STATE.CHASE && doors.at(hitCell) >= 0) {
+        Z.attackTimer[i] -= dt;
+        if (Z.attackTimer[i] <= 0) {
+          Z.attackTimer[i] = N.attackEvery;
+          doors.hit(doors.at(hitCell), N.doorDamage * (tr.doorDamage ?? 1));
+        }
+      }
+      frame(i, dt, d, alive);
+      const spd = Math.hypot(Z.vx[i], Z.vz[i]);
+      Z.renderSpeed[i] += (spd - Z.renderSpeed[i]) * Math.min(1, dt * 6);
+      if (Z.band[i] <= 1) {
+        const s = Z.state[i];
+        let goal = s === STATE.CHASE || s === STATE.GRAB || s === STATE.PILE_STEP ? 1 : 0;
+        if (goal && solidAt(Z.x[i] + Math.sin(Z.renderYaw[i]) * 0.62, Z.z[i] + Math.cos(Z.renderYaw[i]) * 0.62, 1)) goal = 0.1;
+        Z.arms[i] += (goal - Z.arms[i]) * Math.min(1, dt * (goal > Z.arms[i] ? 3 : 5));
+      }
+      Z.phase[i] += dt * (Z.renderSpeed[i] < 0.05 ? 0.15 : N.cadenceBase + N.cadencePerSpeed * Z.renderSpeed[i]);
+      if (spd > 0.35 && Z.state[i] <= 1 && !Z.attackPose[i]) Z.yaw[i] = Math.atan2(Z.vx[i], Z.vz[i]);
+      let dy = Z.yaw[i] - Z.renderYaw[i];
+      dy -= Math.round(dy / TAU_APPROX) * TAU_APPROX;
+      Z.renderYaw[i] += dy * Math.min(1, dt * (Z.state[i] === STATE.AIRBORNE ? 20 : 9));
+    }
+    killQFlush();
+    noises.length = 0;
+    stats.slots = slots;
+  };
+  const updateTrail = (dt, who = target) => {
+    for (const p of trail) p.t += dt;
+    while (trail.length && trail[0].t > N.trailSeconds) trail.shift();
+    if (!who) return;
+    const s = who.state;
+    if ((s.bleeding || s.scentTimer > 0) && s.alive && Math.hypot(s.x - trailLast.x, s.z - trailLast.z) > N.trailStep) {
+      trail.push({ x: s.x, z: s.z, t: 0 });
+      trailLast = { x: s.x, z: s.z };
+      if (trail.length > N.trailMax) trail.shift();
+    }
+  };
+  const spawnAway = (minD, maxD, view) => {
+    const ox = target ? target.state.x : view.x;
+    const oz = target ? target.state.z : view.z;
+    for (let t = 0; t < 30; t++) {
+      const a = R() * TURN;
+      const r = minD + Math.sqrt(R()) * (maxD - minD);
+      const x = ox + Math.cos(a) * r;
+      const z = oz + Math.sin(a) * r;
+      const vx = x - view.x;
+      const vz = z - view.z;
+      const vd = Math.hypot(vx, vz);
+      if (vd < view.far && vx * -Math.sin(view.yaw) + vz * -Math.cos(view.yaw) > vd * 0.5) continue;
+      if (Math.abs(x) < HALF - 3 && Math.abs(z) < HALF - 3 && !grid.blocked(x, z)) return spawn(x, z);
+    }
+    return -1;
+  };
+  const updatePopulation = (dt, view, opts = {}) => {
+    const popTarget = opts.target ?? N.population;
+    let k = 0;
+    while (Z.n < popTarget && k++ < 20) spawnAway(N.refillMin, N.refillMax, view);
+    if (Z.n > popTarget + 120)
+      for (let t = 0, rm = 0; t < 40 && rm < 4; t++) {
+        const i = Math.floor(R() * Z.n);
+        if (Z.band[i] < 2 || Z.named[i] >= 0 || target && i === target.state.grabbedBy) continue;
+        const vx = Z.x[i] - view.x;
+        const vz = Z.z[i] - view.z;
+        const vd = Math.hypot(vx, vz);
+        if (vd < view.far && vx * -Math.sin(view.yaw) + vz * -Math.cos(view.yaw) > -vd * 0.35) continue;
+        remove(i);
+        rm++;
+      }
+    const mg = opts.migration === void 0 ? null : opts.migration;
+    if (!mg) return;
+    migrateT -= dt;
+    if (migrateT <= 0) {
+      migrateT = mg.every;
+      let m = 0;
+      for (let q = 0; q < mg.count && Z.n < Z.capacity; q++) {
+        const i = spawn(mg.x + (R() - 0.5) * mg.width, mg.z + R() * mg.depth);
+        if (i >= 0) {
+          Z.wx[i] = mg.goal[0];
+          Z.wz[i] = mg.goal[1];
+          m++;
+        }
+      }
+      if (m) emit("message", { id: "migration", seconds: 4 });
+    }
+  };
+  const crowd = {
+    store: Z,
+    pack,
+    grid,
+    doors,
+    corpses,
+    numbers: N,
+    stats,
+    pile,
+    pileCount: () => pileN,
+    trail,
+    variantsOf,
+    get target() {
+      return target;
+    },
+    set target(next) {
+      target = next;
+    },
+    random,
+    sound,
+    effect,
+    typeIndex: (id) => typeIndexById.get(id) ?? -1,
+    spawn: (x, z, type = -1) => spawn(x, z, type),
+    remove,
+    update,
+    emitNoise,
+    damage,
+    kill: (i, headshot = false) => kill(i, headshot),
+    updateTrail,
+    updateCorpses: (dt) => void corpses.update(dt),
+    updatePopulation,
+    spawnAway,
+    pileBlast,
+    setHunt(next) {
+      hunt = next;
+    },
+    chaseSpeed,
+    asPlayerCrowd: () => ({
+      count: () => Z.n,
+      active: (i) => Z.band[i] === 0,
+      x: (i) => Z.x[i],
+      z: (i) => Z.z[i],
+      y: (i) => Z.y[i],
+      floor: (i) => Z.floor[i],
+      chasing: (i) => Z.state[i] === STATE.CHASE,
+      down: (i) => Z.crawl[i] !== 0 || Z.state[i] === STATE.STUNNED,
+      panicWeight: (i) => traits(i).panicWeight ?? 1,
+      hold(i, x, z, k, lookX, lookZ) {
+        Z.x[i] += (x - Z.x[i]) * k;
+        Z.z[i] += (z - Z.z[i]) * k;
+        Z.vx[i] = Z.vz[i] = Z.dvx[i] = Z.dvz[i] = 0;
+        Z.yaw[i] = Math.atan2(lookX - Z.x[i], lookZ - Z.z[i]);
+      },
+      stun(i, seconds, vx, vz) {
+        Z.state[i] = STATE.STUNNED;
+        Z.stateTimer[i] = seconds;
+        Z.vx[i] = vx;
+        Z.vz[i] = vz;
+      },
+      chase(i, cooldown) {
+        Z.state[i] = STATE.CHASE;
+        Z.attackTimer[i] = cooldown;
+      },
+      damage: (i, hit) => void damage(i, { region: hit.region, amount: hit.amount, distance: hit.distance, cut: hit.cut, caliber: null })
+    }),
+    on(event, listener) {
+      let set = listeners.get(event);
+      if (!set) listeners.set(event, set = /* @__PURE__ */ new Set());
+      set.add(listener);
+      return () => void set.delete(listener);
+    }
+  };
+  return crowd;
+}
+
+// src/behaviours/civilians.ts
+var CIVILIAN_DEFAULTS = {
+  hpAdult: 100,
+  hpChild: 40,
+  childOffset: 0.6,
+  sightSquared: 100,
+  leaveDistance: 18,
+  attackRange: 1,
+  attackEvery: 1.5,
+  biteFactor: 1.5,
+  biteSeconds: 120,
+  fearAfterHit: 10,
+  nearMessage: 30,
+  fearRange: 6,
+  fearSpeed: 3.4,
+  walkSpeed: 1.3,
+  childSpeed: 0.85,
+  bittenSpeed: 0.8,
+  groupRunBeyond: 6,
+  groupRunSpeed: 3.6,
+  fleeSpeed: 2.6,
+  childFleeFactor: 1.1,
+  stuckSeconds: 8,
+  arrive: 0.25,
+  probe: 0.45,
+  whiskers: [0, 0.7, -0.7, 1.4, -1.4],
+  doorProbe: 0.6,
+  steer: 8,
+  bodyHeight: 0.4,
+  patrolChance: 0.2,
+  childHeight: 0.65,
+  childBuild: 0.7,
+  cadenceBase: 0.5,
+  cadencePerSpeed: 0.3,
+  inside: 0.8,
+  doorInside: 0.8,
+  doorOutside: 0.9,
+  gate: 7.6,
+  sidewalk: 6,
+  houseOffset: 0.8
+};
+function createCivilians(crowd, options) {
+  const N = { ...CIVILIAN_DEFAULTS, ...options.numbers };
+  const Z = crowd.store;
+  const grid = crowd.grid;
+  const doors = crowd.doors;
+  const hourNow = options.hour ?? (() => 12);
+  const turnInto = options.turnInto ?? 0;
+  const listeners = /* @__PURE__ */ new Map();
+  const emit = (event, payload) => {
+    for (const listener of listeners.get(event) ?? []) listener(payload);
+  };
+  const random = crowd.random;
+  const R = random;
+  const lerp = (a, b, t) => a + (b - a) * t;
+  const casaDe = (name) => options.buildings[name];
+  const pontos = options.waypoints ?? ((b) => {
+    const casa = !!b.house;
+    const side = b.front;
+    const front = side < 0 ? b.z + b.d : b.z;
+    const back = side < 0 ? b.z : b.z + b.d;
+    const cx = b.x + b.w / 2;
+    const inw = side < 0 ? -1 : 1;
+    const calc = side < 0 ? -N.sidewalk : N.sidewalk;
+    const pts = [
+      [cx + (casa ? N.houseOffset : 0), (front + (front + back) / 2) / 2],
+      [cx, front + inw * N.doorInside],
+      [cx, front - inw * N.doorOutside]
+    ];
+    if (casa) pts.push([cx, side < 0 ? -N.gate : N.gate]);
+    pts.push([cx, calc]);
+    return pts;
+  });
+  const rota = (bA, bB) => {
+    const a = pontos(bA);
+    const b = pontos(bB).reverse();
+    const out = a.slice();
+    if (Math.sign(a[a.length - 1][1]) !== Math.sign(b[0][1])) out.push([a[a.length - 1][0], b[0][1]]);
+    return out.concat(b);
+  };
+  const list = options.people.map((spec, k) => {
+    const b = casaDe(spec.home);
+    const p = pontos(b)[0];
+    return {
+      id: spec.id,
+      spec,
+      k,
+      x: p[0] + (spec.child ? N.childOffset : 0),
+      z: p[1],
+      yaw: 0,
+      phase: 0,
+      vx: 0,
+      vz: 0,
+      hp: spec.child ? N.hpChild : N.hpAdult,
+      state: "home",
+      path: [],
+      pathIndex: 0,
+      biteTimer: 0,
+      attackTimer: 0,
+      fear: 0,
+      goal: spec.home,
+      stuckTimer: 0,
+      agent: -1
+    };
+  });
+  const byId = new Map(list.map((c) => [c.id, c]));
+  const exposed = (n) => n.state !== "dead" && n.state !== "undead" && n.state !== "gone";
+  const target = () => crowd.target?.state ?? null;
+  const distToTarget = (x, z) => {
+    const t = target();
+    return t ? Math.hypot(x - t.x, z - t.z) : 0;
+  };
+  const turn = (n) => {
+    n.state = "undead";
+    const i = crowd.spawn(n.x, n.z, turnInto);
+    if (i >= 0) {
+      Z.color[i] = n.spec.color ?? Z.color[i];
+      Z.named[i] = n.k;
+      Z.height[i] = n.spec.child ? N.childHeight : Z.height[i];
+      Z.build[i] = n.spec.child ? N.childBuild : Z.build[i];
+      Z.age[i] = 0;
+      Z.state[i] = STATE.CHASE;
+      n.agent = i;
+    }
+    emit("turned", { id: n.id, agent: i });
+  };
+  const die = (n) => {
+    if (n.biteTimer > 0) return turn(n);
+    n.state = "dead";
+    n.vx = n.vz = 0;
+    crowd.corpses.add({
+      x: n.x,
+      z: n.z,
+      yaw: n.yaw,
+      height: n.spec.child ? N.childHeight : 1,
+      build: n.spec.child ? N.childBuild : 1,
+      missing: 0,
+      color: n.spec.color ?? 0,
+      variant: -1,
+      skin: 0.4,
+      seed: R() * 10,
+      named: n.k
+    });
+    crowd.effect({ effect: "blood", point: [n.x, 1, n.z], age: 0, amount: 300, died: true });
+    emit("died", { id: n.id, cause: "attacked" });
+  };
+  const agentsAgainst = (dt) => {
+    const t = target();
+    for (let i = 0; i < Z.n; i++) {
+      if (Z.band[i] > 1) continue;
+      const k = Z.hunts[i];
+      if (k >= 0) {
+        const n = list[k];
+        if (!exposed(n)) {
+          Z.hunts[i] = -1;
+          continue;
+        }
+        const dx = n.x - Z.x[i];
+        const dz = n.z - Z.z[i];
+        const d = Math.hypot(dx, dz);
+        if (d > N.leaveDistance) {
+          Z.hunts[i] = -1;
+          continue;
+        }
+        if (d < N.attackRange) {
+          Z.attackTimer[i] -= dt;
+          if (Z.attackTimer[i] <= 0) {
+            Z.attackTimer[i] = N.attackEvery;
+            const C = crowd.pack.types[Z.type[i]];
+            n.hp -= C.damage;
+            n.fear = N.fearAfterHit;
+            crowd.sound("flesh", 0.7, n.x, 1, n.z, distToTarget(n.x, n.z));
+            crowd.effect({ effect: "blood", point: [n.x, 1.2, n.z], age: 0, amount: 30, died: false });
+            if (n.biteTimer <= 0 && R() < C.bite * N.biteFactor) {
+              n.biteTimer = N.biteSeconds;
+              emit("bitten", { id: n.id, near: distToTarget(n.x, n.z) < N.nearMessage });
+            }
+            if (n.hp <= 0) die(n);
+          }
+        }
+      } else if (Z.state[i] <= 1) {
+        for (const n of list) {
+          if (!exposed(n) || n.state === "home") continue;
+          const dx = n.x - Z.x[i];
+          const dz = n.z - Z.z[i];
+          const d2 = dx * dx + dz * dz;
+          const dp = t ? (t.x - Z.x[i]) ** 2 + (t.z - Z.z[i]) ** 2 : Infinity;
+          if (d2 < N.sightSquared && d2 < dp && grid.losClear(Z.x[i], Z.z[i], n.x, n.z)) {
+            Z.hunts[i] = n.k;
+            Z.state[i] = STATE.CHASE;
+            break;
+          }
+        }
+      }
+    }
+  };
+  crowd.setHunt((i) => {
+    const n = list[Z.hunts[i]];
+    if (!n) return false;
+    const dx = n.x - Z.x[i];
+    const dz = n.z - Z.z[i];
+    const d = Math.hypot(dx, dz) || 1;
+    const sp = d < 1 ? 0 : crowd.chaseSpeed(i);
+    Z.vx[i] = dx / d * sp;
+    Z.vz[i] = dz / d * sp;
+    Z.yaw[i] = Math.atan2(dx, dz);
+    return true;
+  });
+  const move = (n, dt, tx, tz, sp) => {
+    const dx = tx - n.x;
+    const dz = tz - n.z;
+    const d = Math.hypot(dx, dz);
+    if (d < N.arrive) {
+      n.vx = n.vz = 0;
+      return true;
+    }
+    let ax = dx / d;
+    let az = dz / d;
+    for (const a of N.whiskers) {
+      const c2 = Math.cos(a);
+      const s = Math.sin(a);
+      const bx = ax * c2 - az * s;
+      const bz = ax * s + az * c2;
+      if (!grid.solidAt(n.x + bx * N.probe, n.z + bz * N.probe, N.bodyHeight)) {
+        ax = bx;
+        az = bz;
+        break;
+      }
+    }
+    const c = grid.cellOf(n.x + ax * N.doorProbe, n.z + az * N.doorProbe);
+    const di = doors.at(c);
+    if (c >= 0 && di >= 0) {
+      const D = doors.list[di];
+      if (!D.open && !D.broken && !D.planks) {
+        doors.set(di, true);
+        crowd.sound("wood", 0.3, D.x, 1, D.z, distToTarget(D.x, D.z));
+      }
+    }
+    n.vx = lerp(n.vx, ax * sp, Math.min(1, dt * N.steer));
+    n.vz = lerp(n.vz, az * sp, Math.min(1, dt * N.steer));
+    const nx = n.x + n.vx * dt;
+    const nz = n.z + n.vz * dt;
+    if (!grid.solidAt(nx, n.z, N.bodyHeight)) n.x = nx;
+    if (!grid.solidAt(n.x, nz, N.bodyHeight)) n.z = nz;
+    n.yaw = Math.atan2(n.vx, n.vz);
+    return false;
+  };
+  const update = (dt) => {
+    agentsAgainst(dt);
+    const h = hourNow();
+    const t = target();
+    for (const n of list) {
+      if (n.state === "dead" || n.state === "undead" || n.state === "gone") continue;
+      if (n.biteTimer > 0) {
+        n.biteTimer -= dt;
+        if (n.biteTimer <= 0) {
+          turn(n);
+          continue;
+        }
+      }
+      let perto = 99;
+      for (let i = 0; i < Z.n; i++) {
+        if (Z.band[i]) continue;
+        const d = Math.hypot(Z.x[i] - n.x, Z.z[i] - n.z);
+        if (d < perto) perto = d;
+      }
+      const sp = (perto < N.fearRange ? N.fearSpeed : N.walkSpeed) * (n.spec.child ? N.childSpeed : 1) * (n.biteTimer > 0 ? N.bittenSpeed : 1);
+      if (n.state === "group") {
+        const leaderCivilian = n.spec.leader ? byId.get(n.spec.leader) : void 0;
+        const lider = leaderCivilian && leaderCivilian.state === "group" ? leaderCivilian : t;
+        if (lider) {
+          const dd = Math.hypot(lider.x - n.x, lider.z - n.z);
+          if (dd > (n.spec.followDistance ?? 2.2)) move(n, dt, lider.x, lider.z, dd > N.groupRunBeyond ? N.groupRunSpeed : sp);
+          else {
+            n.vx *= 0.8;
+            n.vz *= 0.8;
+          }
+        }
+      } else if (n.state === "fleeing") {
+        const p = n.path[n.pathIndex];
+        if (!p) {
+          n.state = "gone";
+          emit("gone", { id: n.id });
+          continue;
+        }
+        n.stuckTimer += dt;
+        if (move(n, dt, p[0], p[1], N.fleeSpeed * (n.spec.child ? N.childFleeFactor : 1)) || n.stuckTimer > N.stuckSeconds) {
+          n.pathIndex++;
+          n.stuckTimer = 0;
+        }
+      } else if (n.spec.routine) {
+        let alvo = n.spec.home;
+        for (const [hh, onde] of n.spec.routine) if (h >= hh && h < hh + 1) alvo = onde;
+        if (perto < N.fearRange) alvo = n.spec.home;
+        if (alvo !== n.goal) {
+          const home = casaDe(n.spec.home);
+          n.path = rota(casaDe(n.goal) ?? home, casaDe(alvo) ?? home);
+          n.pathIndex = 0;
+          n.goal = alvo;
+          n.state = "walking";
+        }
+        if (n.state === "walking") {
+          const p = n.path[n.pathIndex];
+          n.stuckTimer += dt;
+          if (!p) n.state = "home";
+          else if (move(n, dt, p[0], p[1], sp) || n.stuckTimer > N.stuckSeconds) {
+            n.pathIndex++;
+            n.stuckTimer = 0;
+          }
+        } else {
+          n.vx *= 0.8;
+          n.vz *= 0.8;
+        }
+      } else {
+        n.vx *= 0.8;
+        n.vz *= 0.8;
+      }
+      {
+        const v = Math.hypot(n.vx, n.vz);
+        n.phase += dt * (v < 0.05 ? 0 : N.cadenceBase + N.cadencePerSpeed * v);
+      }
+    }
+    for (let i = 0; i < Z.n; i++)
+      if (Z.named[i] >= 0 && Z.state[i] === STATE.WANDER && R() < dt * N.patrolChance) {
+        const n = list[Z.named[i]];
+        if (!n) continue;
+        const p = pontos(casaDe(n.spec.home));
+        const q = p[Math.floor(R() * p.length)];
+        Z.wx[i] = q[0];
+        Z.wz[i] = q[1];
+      }
+  };
+  return {
+    list,
+    get: (id) => byId.get(id),
+    update,
+    join(id) {
+      const n = byId.get(id);
+      if (n && exposed(n)) n.state = "group";
+    },
+    flee(id, path) {
+      const n = byId.get(id);
+      if (!n || !exposed(n)) return;
+      n.state = "fleeing";
+      n.path = path.map(([x, z]) => [x, z]);
+      n.pathIndex = 0;
+    },
+    route(from, to) {
+      return rota(casaDe(from), casaDe(to));
+    },
+    on(event, listener) {
+      let set = listeners.get(event);
+      if (!set) listeners.set(event, set = /* @__PURE__ */ new Set());
+      set.add(listener);
+      return () => void set.delete(listener);
+    }
+  };
+}
+
+// src/behaviours/herd.ts
+var HERD_DEFAULTS = {
+  range: 8,
+  fear: 5,
+  walkFactor: 1.05,
+  walkBase: 0.25,
+  runFactor: 2.2,
+  runBase: 0.8,
+  activeDistance: 70,
+  companionBehind: 2.2,
+  companionRun: 6,
+  companionStop: 0.8,
+  retargetTries: 6,
+  restBase: 4,
+  restRandom: 7,
+  lookEvery: 7,
+  lookShare: 0.25,
+  lookRadius: 40,
+  fearAgentFactor: 1.5,
+  fearAgentBase: 2,
+  fleeStep: 6,
+  arrive: 0.3,
+  bodyHeight: 0.3,
+  turn: 6,
+  freeHeight: 0.6,
+  worldMargin: 4
+};
+var HERD_ROLES = {
+  dog: { range: 6, fear: 0, guard: { bark: 12, barkNoise: 60, barkCooldown: 3, growl: 40, growlCooldown: 10, sound: "bark" } },
+  cat: { range: 6, fear: 5 },
+  chicken: { range: 5, fear: 4, fleeCall: { sound: "cluck", noise: 30, cooldown: 6 } },
+  southern_lapwing: { range: 5, fear: 0, alarm: { range: 12, sound: "lapwing", noise: 40, cooldown: 8, fly: 4 } },
+  cow: { range: 10, fear: 6, call: { chance: 0.02, sound: "moo", noise: 80, cooldown: 30 } },
+  horse: { range: 10, fear: 7 },
+  pig: { range: 5, fear: 3 },
+  capybara: { range: 8, fear: 15 },
+  vulture: { sky: true }
+};
+function createHerd(crowd, options = {}) {
+  const N = { ...HERD_DEFAULTS, ...options.numbers };
+  const R = crowd.random;
+  const Z = crowd.store;
+  const grid = crowd.grid;
+  const list = [];
+  let time = 0;
+  const listeners = /* @__PURE__ */ new Map();
+  const emit = (event, payload) => {
+    for (const listener of listeners.get(event) ?? []) listener(payload);
+  };
+  const view = options.view ?? (() => crowd.target?.state ?? { x: 0, z: 0 });
+  const free = (x0, z0, r0, r1, tries = 40) => {
+    for (let k = 0; k < tries; k++) {
+      const a = R() * 6.28;
+      const r = r0 + R() * (r1 - r0);
+      const x = x0 + Math.cos(a) * r;
+      const z = z0 + Math.sin(a) * r;
+      if (Math.abs(x) < grid.half - N.worldMargin && Math.abs(z) < grid.half - N.worldMargin && !grid.solidAt(x, z, N.freeHeight) && !options.blocked?.(x, z)) return [x, z];
+    }
+    return null;
+  };
+  const nearestAgent = (x, z, r) => {
+    let best = -1;
+    let bd = r * r;
+    for (let i = 0; i < Z.n; i++) {
+      if (Z.state[i] === STATE.DORMANT) continue;
+      const dx = Z.x[i] - x;
+      const dz = Z.z[i] - z;
+      const d = dx * dx + dz * dz;
+      if (d < bd) {
+        bd = d;
+        best = i;
+      }
+    }
+    return best < 0 ? null : [best, Math.sqrt(bd)];
+  };
+  const call = (E, sound, noise, dc) => {
+    crowd.emitNoise(E.x, E.z, noise);
+    emit("noise", { x: E.x, z: E.z, radius: noise, animal: E.index });
+    emit("sound", { sound, volume: 1, position: [E.x, 0.5, E.z], distance: dc, animal: E.index });
+  };
+  const update = (dt) => {
+    time += dt;
+    const t = crowd.target?.state;
+    const px = t?.x ?? 0;
+    const pz = t?.z ?? 0;
+    const v = view();
+    for (const E of list) {
+      if (E.spec.sky) continue;
+      const dc = Math.hypot(E.x - v.x, E.z - v.z);
+      if (dc >= N.activeDistance || E.dead) continue;
+      E.timer -= dt;
+      E.cooldown -= dt;
+      let alvoX = E.targetX;
+      let alvoZ = E.targetZ;
+      let corre = false;
+      const dp = t ? Math.hypot(E.x - px, E.z - pz) : Infinity;
+      if (E.companion && t) {
+        const bx = px - Math.sin(t.yaw) * N.companionBehind;
+        const bz = pz - Math.cos(t.yaw) * N.companionBehind;
+        alvoX = bx;
+        alvoZ = bz;
+        corre = dp > N.companionRun;
+        if (Math.hypot(bx - E.x, bz - E.z) < N.companionStop) {
+          alvoX = E.x;
+          alvoZ = E.z;
+        }
+      } else if (E.timer <= 0) {
+        const q = free(E.homeX, E.homeZ, 0, E.range, N.retargetTries);
+        if (q) {
+          E.targetX = q[0];
+          E.targetZ = q[1];
+        }
+        E.timer = N.restBase + R() * N.restRandom;
+        alvoX = E.targetX;
+        alvoZ = E.targetZ;
+      }
+      const zp = (time * N.lookEvery + E.x) % 1 < N.lookShare || E.near === void 0 ? E.near = nearestAgent(E.x, E.z, N.lookRadius) : E.near;
+      let fx = 0;
+      let fz = 0;
+      if (E.fear && !E.companion && dp < E.fear) {
+        fx += E.x - px;
+        fz += E.z - pz;
+      }
+      if (E.fear && zp && zp[1] < E.fear * N.fearAgentFactor + N.fearAgentBase) {
+        fx += E.x - Z.x[zp[0]];
+        fz += E.z - Z.z[zp[0]];
+      }
+      if (fx || fz) {
+        const l = Math.hypot(fx, fz) || 1;
+        alvoX = E.x + fx / l * N.fleeStep;
+        alvoZ = E.z + fz / l * N.fleeStep;
+        corre = true;
+        const fc = E.spec.fleeCall;
+        if (fc && E.cooldown <= 0) {
+          E.cooldown = fc.cooldown;
+          call(E, fc.sound, fc.noise, dc);
+        }
+      }
+      const al = E.spec.alarm;
+      if (al && dp < al.range && E.cooldown <= 0) {
+        E.cooldown = al.cooldown;
+        E.fly = al.fly;
+        call(E, al.sound, al.noise, dc);
+        emit("message", { id: "alarm", seconds: 2.5, animal: E.index });
+      }
+      const cl = E.spec.call;
+      if (cl && E.cooldown <= 0 && R() < dt * cl.chance) {
+        E.cooldown = cl.cooldown;
+        call(E, cl.sound, cl.noise, dc);
+      }
+      const g = E.spec.guard;
+      if (g && zp && E.cooldown <= 0) {
+        if (zp[1] < g.bark) {
+          E.cooldown = g.barkCooldown;
+          call(E, g.sound, g.barkNoise, dc);
+          if (E.companion) emit("message", { id: "bark", seconds: 1.5, animal: E.index, distance: Math.round(zp[1]) });
+        } else if (E.companion && zp[1] < g.growl) {
+          E.cooldown = g.growlCooldown;
+          emit("message", { id: "growl", seconds: 2.5, animal: E.index, distance: Math.round(zp[1]) });
+        }
+      }
+      const ax = alvoX - E.x;
+      const az = alvoZ - E.z;
+      const ad = Math.hypot(ax, az);
+      let sp = 0;
+      if (E.fly > 0) {
+        E.fly -= dt;
+        E.clip = "run";
+      } else if (ad > N.arrive) {
+        sp = corre ? E.runSpeed : E.walkSpeed;
+        E.clip = corre ? "run" : "walk";
+      } else E.clip = "idle";
+      if (sp) {
+        const k = Math.min(1, sp * dt / ad);
+        const nx = E.x + ax * k;
+        const nz = E.z + az * k;
+        if (!grid.solidAt(nx, nz, N.bodyHeight)) {
+          E.x = nx;
+          E.z = nz;
+        } else E.timer = 0;
+        let dy = Math.atan2(ax, az) - E.yaw;
+        dy -= Math.round(dy / 6.2832) * 6.2832;
+        E.yaw += dy * Math.min(1, dt * N.turn);
+      }
+    }
+  };
+  return {
+    list,
+    add(spec) {
+      const E = {
+        index: list.length,
+        spec,
+        x: spec.x,
+        z: spec.z,
+        yaw: R() * 6.28,
+        homeX: spec.x,
+        homeZ: spec.z,
+        range: spec.range ?? N.range,
+        clip: "idle",
+        timer: R() * 4,
+        targetX: spec.x,
+        targetZ: spec.z,
+        fear: spec.fear ?? N.fear,
+        fly: 0,
+        cooldown: 0,
+        walkSpeed: spec.walkHz * spec.size * N.walkFactor + N.walkBase,
+        runSpeed: spec.runHz * spec.size * N.runFactor + N.runBase,
+        companion: !!spec.companion,
+        dead: !!spec.dead,
+        near: void 0
+      };
+      list.push(E);
+      return E;
+    },
+    free,
+    update,
+    get time() {
+      return time;
+    },
+    setCompanion(index, on) {
+      const E = list[index];
+      if (!E) return;
+      E.companion = on;
+      E.homeX = E.x;
+      E.homeZ = E.z;
+    },
+    on(event, listener) {
+      let set = listeners.get(event);
+      if (!set) listeners.set(event, set = /* @__PURE__ */ new Set());
+      set.add(listener);
+      return () => void set.delete(listener);
+    }
+  };
+}
+
+// src/behaviours/flock.ts
+var carrionCenter = (corpses, fallback) => {
+  let ux = 0;
+  let uz = 0;
+  let un = 0;
+  for (const c of corpses) {
+    ux += c.x;
+    uz += c.z;
+    un++;
+  }
+  if (un >= 3) return [ux / un, uz / un];
+  return fallback ? [fallback[0], fallback[1]] : [ux, uz];
+};
+function createFlock(options) {
+  const birds = Array.from({ length: options.count }, () => ({ x: 0, y: 0, z: 0, yaw: 0, roll: 0, wing: 0, visible: true }));
+  const within = options.visibleWithin ?? (options.mode === "carrion" ? 260 : Infinity);
+  return {
+    birds,
+    update(t, dt, [cx, cz], view) {
+      birds.forEach((U, i) => {
+        if (options.mode === "carrion") {
+          const a = t * (0.18 + i * 0.04) + i * 2.1;
+          const r = 7 + i * 2;
+          U.x = cx + Math.cos(a) * r;
+          U.y = 16 + i * 2.5;
+          U.z = cz + Math.sin(a) * r;
+          U.yaw = -a;
+          U.roll = 0.35;
+          U.visible = !view || Math.hypot(cx - view[0], cz - view[1]) < within;
+          if (U.visible) U.wing += dt * 1.2 * 2 * Math.PI;
+        } else {
+          const a = t * 0.3 + i * 0.4;
+          const r = 20 + i % 7 * 4;
+          U.x = cx + Math.cos(a) * r;
+          U.y = 25 + Math.sin(t + i) * 2;
+          U.z = cz + Math.sin(a) * r;
+          U.yaw = -a;
+          U.roll = 0;
+          U.visible = !view || Math.hypot(cx - view[0], cz - view[1]) < within;
+        }
+      });
+    }
+  };
+}
+
+// src/behaviours/infection.ts
+function bindInfection(crowd, model, options) {
+  const tracked = /* @__PURE__ */ new Map();
+  const band = options.giveBackBand ?? 3;
+  const offKill = crowd.on("kill", ({ agent }) => {
+    const entry = tracked.get(agent);
+    if (!entry) return;
+    model.giveBack(entry.region, [{ state: "removed", seed: entry.seed }]);
+    tracked.delete(agent);
+  });
+  const offRemove = crowd.on("remove", ({ agent, moved }) => {
+    tracked.delete(agent);
+    if (moved < 0) return;
+    const entry = tracked.get(moved);
+    if (!entry) return;
+    tracked.delete(moved);
+    tracked.set(agent, entry);
+  });
+  const offBite = options.civilians?.on("bitten", ({ id }) => {
+    const n = options.civilians?.get(id);
+    const region = n && options.regionOf?.(n.x, n.z);
+    if (region) model.infect(region, 1, 0);
+  });
+  return {
+    materialize(region, n) {
+      const batch = model.materialize(region, n);
+      const born = [];
+      const back = [];
+      batch.forEach((agent, k) => {
+        const at = options.place(region, agent.seed, k);
+        const i = at ? crowd.spawn(at[0], at[1], options.typeFor?.(agent, region) ?? -1) : -1;
+        if (i < 0) {
+          back.push(agent);
+          return;
+        }
+        tracked.set(i, { region, state: agent.state, seed: agent.seed });
+        born.push(i);
+      });
+      if (back.length) model.giveBack(region, back);
+      return born;
+    },
+    giveBack(region, opts = {}) {
+      const byRegion = /* @__PURE__ */ new Map();
+      const indices = [...tracked.keys()].sort((a, b) => b - a);
+      for (const i of indices) {
+        const entry = tracked.get(i);
+        if (!entry || region !== void 0 && entry.region !== region) continue;
+        if (!opts.all && crowd.store.band[i] < band) continue;
+        let list = byRegion.get(entry.region);
+        if (!list) byRegion.set(entry.region, list = []);
+        list.push({ state: entry.state, seed: entry.seed });
+        tracked.delete(i);
+        crowd.remove(i);
+      }
+      let count = 0;
+      for (const [r, list] of byRegion) {
+        model.giveBack(r, list);
+        count += list.length;
+      }
+      return count;
+    },
+    regionOf: (agent) => tracked.get(agent)?.region ?? null,
+    unbind() {
+      offKill();
+      offRemove();
+      offBite?.();
+      tracked.clear();
+    }
+  };
+}
+export {
+  AGENT_FIELDS,
+  CELL,
+  CIVILIAN_DEFAULTS,
+  CROWD_DEFAULTS,
+  DOOR_DEFAULTS,
+  HERD_DEFAULTS,
+  HERD_ROLES,
+  MISSING,
+  STATE,
+  bindInfection,
+  carrionCenter,
+  createCivilians,
+  createCrowd,
+  createDoors,
+  createFlock,
+  createHerd,
+  createNavGrid,
+  createRng,
+  createStore
+};
+//# sourceMappingURL=index.js.map