@adatechnology/game-crowd 0.0.0-stage → 0.2.0

package/dist/index.global.js

@@ -0,0 +1,3282 @@
+"use strict";
+var GameCrowd = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    AGENT_FIELDS: () => AGENT_FIELDS,
+    CELL: () => CELL,
+    CIVILIAN_DEFAULTS: () => CIVILIAN_DEFAULTS,
+    CROWD_DEFAULTS: () => CROWD_DEFAULTS,
+    DOOR_DEFAULTS: () => DOOR_DEFAULTS,
+    HERD_DEFAULTS: () => HERD_DEFAULTS,
+    HERD_ROLES: () => HERD_ROLES,
+    MISSING: () => MISSING,
+    STATE: () => STATE,
+    bindInfection: () => bindInfection,
+    carrionCenter: () => carrionCenter,
+    createCivilians: () => createCivilians,
+    createCrowd: () => createCrowd,
+    createDoors: () => createDoors,
+    createFlock: () => createFlock,
+    createHerd: () => createHerd,
+    createNavGrid: () => createNavGrid,
+    createRng: () => createRng,
+    createStore: () => createStore
+  });
+
+  // ../game-contracts/dist/index.js
+  var MISSING_BITS = {
+    head: 1,
+    armL: 2,
+    armR: 4,
+    legL: 8,
+    legR: 16,
+    armLBroken: 32,
+    armRBroken: 64,
+    legLBroken: 128,
+    legRBroken: 256,
+    jaw: 512
+  };
+
+  // ../game-characters/dist/index.js
+  var __defProp2 = Object.defineProperty;
+  var __export2 = (target, all) => {
+    for (var name in all)
+      __defProp2(target, name, { get: all[name], enumerable: true });
+  };
+  var body_default = {
+    guide: {
+      heightMetres: 1.8,
+      shoulderWidthMetres: 0.61,
+      shoulderWidthWomanMetres: 0.57,
+      shoulderHeightMetres: 1.475,
+      headToHeight: 0.1667
+    },
+    teamGame: {
+      source: "G 65336 J (shoulders +-0.24 m)",
+      joints: {
+        quadril: [
+          0,
+          0.95,
+          0
+        ],
+        pescoco: [
+          0,
+          1.52,
+          0
+        ],
+        ombroE: [
+          -0.24,
+          1.44,
+          0
+        ],
+        ombroD: [
+          0.24,
+          1.44,
+          0
+        ],
+        cotoveloE: [
+          -0.27,
+          1.13,
+          0
+        ],
+        cotoveloD: [
+          0.27,
+          1.13,
+          0
+        ],
+        coxaE: [
+          -0.1,
+          0.92,
+          0
+        ],
+        coxaD: [
+          0.1,
+          0.92,
+          0
+        ],
+        joelhoE: [
+          -0.1,
+          0.5,
+          0
+        ],
+        joelhoD: [
+          0.1,
+          0.5,
+          0
+        ]
+      },
+      heightMetres: 1.8
+    },
+    lodDistancesMetres: [
+      18,
+      55
+    ],
+    triangleBudget: {
+      lod0: 2500,
+      lod1: 800,
+      lod2: 250
+    }
+  };
+  var SEGMENT_RADIUS = {
+    head: 0.1,
+    jaw: 0.05,
+    neck: 0.06,
+    torso: 0.17,
+    pelvis: 0.16,
+    upperArm: 0.085,
+    forearm: 0.065,
+    hand: 0.05,
+    thigh: 0.1,
+    shin: 0.08,
+    foot: 0.05
+  };
+  var { guide } = body_default;
+  var shoulderX = guide.shoulderWidthMetres / 2;
+  var shoulderY = guide.shoulderHeightMetres;
+  var GUIDE = {
+    id: "guide",
+    heightMetres: guide.heightMetres,
+    joints: {
+      hip: [0, 0.92, 0],
+      spine: [0, 1.05, 0],
+      neck: [0, 1.56, 0],
+      head: [0, 1.64, 0],
+      jaw: [0, 1.66, 0.06],
+      shoulderL: [shoulderX, shoulderY, 0],
+      shoulderR: [-shoulderX, shoulderY, 0],
+      elbowL: [shoulderX, shoulderY - 0.31, 0],
+      elbowR: [-shoulderX, shoulderY - 0.31, 0],
+      wristL: [shoulderX, shoulderY - 0.61, 0],
+      wristR: [-shoulderX, shoulderY - 0.61, 0],
+      hipL: [0.105, 0.9, 0],
+      hipR: [-0.105, 0.9, 0],
+      kneeL: [0.105, 0.48, 0],
+      kneeR: [-0.105, 0.48, 0],
+      ankleL: [0.105, 0.1, 0],
+      ankleR: [-0.105, 0.1, 0]
+    },
+    segmentRadius: SEGMENT_RADIUS
+  };
+  var J = body_default.teamGame.joints;
+  var below = (point, drop) => [point[0], point[1] - drop, point[2]];
+  var TEAM_GAME = {
+    id: "team-game",
+    heightMetres: body_default.teamGame.heightMetres,
+    joints: {
+      hip: J.quadril,
+      spine: J.quadril,
+      neck: J.pescoco,
+      head: J.pescoco,
+      jaw: [0, J.pescoco[1] + 0.08, 0.06],
+      shoulderL: J.ombroE,
+      shoulderR: J.ombroD,
+      elbowL: J.cotoveloE,
+      elbowR: J.cotoveloD,
+      wristL: below(J.cotoveloE, 0.3),
+      wristR: below(J.cotoveloD, 0.3),
+      hipL: J.coxaE,
+      hipR: J.coxaD,
+      kneeL: J.joelhoE,
+      kneeR: J.joelhoD,
+      ankleL: below(J.joelhoE, 0.42),
+      ankleR: below(J.joelhoD, 0.42)
+    },
+    segmentRadius: SEGMENT_RADIUS
+  };
+  var createCorpseLedger = (options) => {
+    const entries = [];
+    return {
+      entries,
+      get count() {
+        return entries.length;
+      },
+      add(data) {
+        if (entries.length < options.max) {
+          entries.push({ age: 0, data });
+          return void 0;
+        }
+        let oldest = 0;
+        for (let index = 1; index < entries.length; index++) if (entries[index].age > entries[oldest].age) oldest = index;
+        const replaced = entries[oldest].data;
+        entries[oldest] = { age: 0, data };
+        return replaced;
+      },
+      update(dt) {
+        const removed = [];
+        for (let index = 0; index < entries.length; index++) {
+          const entry = entries[index];
+          entry.age += dt;
+          if (entry.age <= options.seconds) continue;
+          removed.push(entry.data);
+          entries[index] = entries[entries.length - 1];
+          entries.pop();
+          index--;
+        }
+        return removed;
+      },
+      remove(index) {
+        const entry = entries[index];
+        if (!entry) return void 0;
+        entries[index] = entries[entries.length - 1];
+        entries.pop();
+        return entry.data;
+      },
+      clear() {
+        entries.length = 0;
+      }
+    };
+  };
+  var team_game_default = {
+    id: "team-game",
+    segments: {
+      head: 40,
+      arm: 60,
+      leg: 80
+    },
+    calibers: {
+      "7_62x51": {
+        gameKey: "308",
+        name: "7,62\xD751 (.308)",
+        points: 75,
+        penetration: 4,
+        effectiveRangeMetres: 600,
+        noiseMetres: 130,
+        skullRange: 1,
+        class: "rifle"
+      },
+      "9x19": {
+        gameKey: "9x19",
+        name: "9\xD719 mm",
+        points: 35,
+        penetration: 1.2,
+        effectiveRangeMetres: 35,
+        noiseMetres: 60,
+        skullRange: 1,
+        class: "pistol"
+      },
+      "12ga_00buck": {
+        gameKey: "12ga",
+        name: "12 ga 00",
+        points: 12,
+        pellets: 9,
+        penetration: 0.5,
+        effectiveRangeMetres: 15,
+        noiseMetres: 90,
+        skullRange: 8,
+        class: "pistol"
+      },
+      "7_62x39": {
+        gameKey: "762x39",
+        name: "7,62\xD739 mm",
+        points: 55,
+        penetration: 3,
+        effectiveRangeMetres: 250,
+        noiseMetres: 110,
+        skullRange: 1,
+        class: "rifle"
+      }
+    },
+    regionCost: {
+      head: 0.7,
+      torso: 1,
+      bruteTorso: 2,
+      limb: 0.5
+    },
+    damageKeptPerBody: 0.75,
+    falloff: {
+      fullAtRange: 1,
+      atTwiceRange: 0.5
+    },
+    helmetAbsorbs: "pistol",
+    regions: [
+      "head",
+      "torso",
+      "armL",
+      "armR",
+      "legL",
+      "legR"
+    ]
+  };
+  var REGION_HIT_POINTS = {
+    head: team_game_default.segments.head,
+    armL: team_game_default.segments.arm,
+    armR: team_game_default.segments.arm,
+    legL: team_game_default.segments.leg,
+    legR: team_game_default.segments.leg
+  };
+  var segments_default = {
+    segments: [
+      {
+        id: "head",
+        region: "head",
+        hitPoints: 40,
+        multiplier: 3,
+        bleed: 40
+      },
+      {
+        id: "jaw",
+        region: "head",
+        hitPoints: 12,
+        multiplier: 2,
+        bleed: 8
+      },
+      {
+        id: "neck",
+        region: "head",
+        hitPoints: 25,
+        multiplier: 2,
+        bleed: 46
+      },
+      {
+        id: "torso",
+        region: "torso",
+        hitPoints: 150,
+        multiplier: 1,
+        bleed: 10
+      },
+      {
+        id: "pelvis",
+        region: "torso",
+        hitPoints: 90,
+        multiplier: 1,
+        bleed: 12
+      },
+      {
+        id: "upperArm",
+        region: "arm",
+        hitPoints: 45,
+        multiplier: 0.6,
+        bleed: 15
+      },
+      {
+        id: "forearm",
+        region: "arm",
+        hitPoints: 30,
+        multiplier: 0.6,
+        bleed: 8
+      },
+      {
+        id: "hand",
+        region: "arm",
+        hitPoints: 12,
+        multiplier: 0.6,
+        bleed: 3
+      },
+      {
+        id: "thigh",
+        region: "leg",
+        hitPoints: 55,
+        multiplier: 0.7,
+        bleed: 19
+      },
+      {
+        id: "shin",
+        region: "leg",
+        hitPoints: 40,
+        multiplier: 0.7,
+        bleed: 9
+      },
+      {
+        id: "foot",
+        region: "leg",
+        hitPoints: 15,
+        multiplier: 0.7,
+        bleed: 3
+      }
+    ],
+    regions: {
+      head: {
+        hitPoints: 40,
+        segmentSum: 77,
+        scale: 0.5195
+      },
+      arm: {
+        hitPoints: 60,
+        segmentSum: 87,
+        scale: 0.6897
+      },
+      leg: {
+        hitPoints: 80,
+        segmentSum: 110,
+        scale: 0.7273
+      }
+    },
+    arsenalWeapons: {
+      pistola: {
+        n: "Pistola 9\xD719",
+        dmg: 35,
+        pel: 1
+      },
+      fuzil: {
+        n: "Fuzil 7,62\xD739",
+        dmg: 55,
+        pel: 1
+      },
+      escopeta: {
+        n: "Escopeta 12 ga",
+        dmg: 12,
+        pel: 9
+      },
+      cinquenta: {
+        n: ".50 BMG",
+        dmg: 180,
+        pel: 1
+      },
+      granada: {
+        n: "Granada",
+        dmg: 300,
+        pel: 0
+      }
+    },
+    elenco: {
+      segments: {
+        head: {
+          hp: 40,
+          radius: 0.07
+        },
+        torso: {
+          hp: 120
+        },
+        pelvis: {
+          hp: 90
+        },
+        upperArm: {
+          hp: 60,
+          radius: 0.085
+        },
+        forearm: {
+          hp: 45,
+          radius: 0.065
+        },
+        hand: {
+          hp: 25,
+          radius: 0.05
+        },
+        thigh: {
+          hp: 80,
+          radius: 0.1
+        },
+        shin: {
+          hp: 55,
+          radius: 0.08
+        }
+      },
+      below: {
+        upperArm: [
+          "forearm",
+          "hand"
+        ],
+        forearm: [
+          "hand"
+        ],
+        thigh: [
+          "shin"
+        ]
+      },
+      falls: {
+        upperArm: "o bra\xE7o inteiro",
+        forearm: "o antebra\xE7o com a m\xE3o",
+        hand: "a m\xE3o",
+        thigh: "a perna inteira",
+        shin: "a canela com o p\xE9",
+        head: "a cabe\xE7a"
+      },
+      cutWeapons: [
+        {
+          id: "faca",
+          n: "Faca",
+          dmg: 22,
+          cut: 0.7
+        },
+        {
+          id: "facao",
+          n: "Fac\xE3o",
+          dmg: 55,
+          cut: 1
+        },
+        {
+          id: "machado",
+          n: "Machado",
+          dmg: 85,
+          cut: 1
+        },
+        {
+          id: "p9",
+          n: "Pistola 9 mm",
+          dmg: 30,
+          cut: 0.15
+        },
+        {
+          id: "e12",
+          n: "Espingarda 12",
+          dmg: 95,
+          cut: 0.75
+        },
+        {
+          id: "f762",
+          n: "Fuzil 7,62",
+          dmg: 65,
+          cut: 0.45
+        }
+      ]
+    },
+    severity: {
+      severAtCut: 0.5,
+      severAtDamageFraction: 0.9,
+      destroyAtDamageMultiple: 2,
+      limpAtHpFraction: 0.5,
+      splitAtDamage: 150,
+      headKillDamage: 20,
+      jawChance: 0.3,
+      jawDamage: 25,
+      headBitDamage: 60,
+      headBitShotgunMetres: 5
+    },
+    defaultCut: {
+      slash: 0.85,
+      blunt: 0,
+      explosive: 1,
+      ballistic: {
+        pistol: 0.15,
+        buckshot: 0.75,
+        rifle: 0.45
+      }
+    },
+    deathRule: {
+      default: "vitality-or-head",
+      options: [
+        "vitality-or-head",
+        "head-only"
+      ]
+    }
+  };
+  var limb = (kind, side, joint, parent, slots) => {
+    const isArm2 = kind === "upperArm" || kind === "forearm" || kind === "hand";
+    const region = isArm2 ? side === "L" ? "armL" : "armR" : side === "L" ? "legL" : "legR";
+    return { id: `${kind}${side}`, kind, side, joint, region, slots, ...parent ? { parent } : {} };
+  };
+  var sideOf = (side) => [
+    limb("upperArm", side, `shoulder${side}`, "torso", ["arms"]),
+    limb("forearm", side, `elbow${side}`, `upperArm${side}`, ["arms"]),
+    limb("hand", side, `wrist${side}`, `forearm${side}`, ["hands"]),
+    limb("thigh", side, `hip${side}`, "pelvis", ["legs"]),
+    limb("shin", side, `knee${side}`, `thigh${side}`, ["legs"]),
+    limb("foot", side, `ankle${side}`, `shin${side}`, ["feet"])
+  ];
+  var SEGMENT_TREE = [
+    { id: "pelvis", kind: "pelvis", joint: "hip", region: "torso", slots: ["torso"] },
+    { id: "torso", kind: "torso", joint: "spine", parent: "pelvis", region: "torso", slots: ["torso"] },
+    { id: "neck", kind: "neck", joint: "neck", parent: "torso", region: "head", slots: [] },
+    { id: "head", kind: "head", joint: "head", parent: "neck", region: "head", slots: ["head", "eyes"] },
+    { id: "jaw", kind: "jaw", joint: "jaw", parent: "head", region: "head", slots: [] },
+    ...sideOf("L"),
+    ...sideOf("R")
+  ];
+  var SEGMENT_IDS = SEGMENT_TREE.map((node) => node.id);
+  var NODES = new Map(SEGMENT_TREE.map((node) => [node.id, node]));
+  var SEGMENT_NUMBERS = Object.fromEntries(
+    segments_default.segments.map((entry) => [entry.id, { hitPoints: entry.hitPoints, multiplier: entry.multiplier, bleed: entry.bleed }])
+  );
+  var LIMB_MASK = [
+    { ids: ["upperArmL", "forearmL"], lost: MISSING_BITS.armL, broken: MISSING_BITS.armLBroken },
+    { ids: ["upperArmR", "forearmR"], lost: MISSING_BITS.armR, broken: MISSING_BITS.armRBroken },
+    { ids: ["thighL", "shinL"], lost: MISSING_BITS.legL, broken: MISSING_BITS.legLBroken },
+    { ids: ["thighR", "shinR"], lost: MISSING_BITS.legR, broken: MISSING_BITS.legRBroken }
+  ];
+  var physical_default = {
+    id: "physical",
+    tissuePerCentimetre: {
+      flesh: 0.25,
+      bone: 1
+    },
+    torsoPath: {
+      fleshCentimetres: 22,
+      boneCentimetres: 2
+    },
+    regionFactor: {
+      head: 0.7,
+      limb: 0.5,
+      torso: 1
+    },
+    bruteTorsoFactor: 2,
+    energyKept: "P / (P + R)",
+    points: {
+      coefficient: 3.5,
+      exponent: 0.37
+    },
+    tolerance: {
+      bodies: 0,
+      energyKept: 0.05
+    },
+    calibration: [
+      {
+        caliber: "9x19",
+        force: 7.67,
+        bodies: 2,
+        energyKeptFirstBody: 0.51,
+        expectedBodies: 2,
+        bestiaryEnergyKept: 0.5
+      },
+      {
+        caliber: "5_56x45",
+        force: 16.56,
+        bodies: 3,
+        energyKeptFirstBody: 0.69,
+        expectedBodies: 3,
+        bestiaryEnergyKept: 0.65
+      },
+      {
+        caliber: "7_62x51",
+        force: 26.67,
+        bodies: 4,
+        energyKeptFirstBody: 0.78,
+        expectedBodies: 4,
+        bestiaryEnergyKept: 0.75
+      },
+      {
+        caliber: "7_62x39",
+        force: 18.52,
+        bodies: 3,
+        energyKeptFirstBody: 0.71,
+        expectedBodies: 3
+      },
+      {
+        caliber: "12ga_00buck",
+        force: 4.35,
+        bodies: 1,
+        energyKeptFirstBody: 0.37,
+        expectedBodies: 1
+      }
+    ],
+    torsoResistance: 7.5
+  };
+  var { severity } = segments_default;
+  var DEFAULT_DAMAGE_RULES = {
+    deathRule: "vitality-or-head",
+    segmentRule: "kit",
+    severity: { ...severity, stunAtPoints: 35, limbVitalityShare: 0.3, regionLimbVitalityShare: 0.5 },
+    blast: { minimumPoints: 8, headDestroyPoints: 40, bigPoints: 120 },
+    defaultCut: segments_default.defaultCut,
+    points: physical_default.points,
+    spread: 0,
+    segments: SEGMENT_NUMBERS,
+    burnPointsPerSecond: 3
+  };
+  var ARSENAL_RULES = { ...DEFAULT_DAMAGE_RULES, segmentRule: "arsenal" };
+  var ELENCO_HIT_POINTS = segments_default.elenco.segments;
+  var ELENCO_RULES = {
+    ...DEFAULT_DAMAGE_RULES,
+    segmentRule: "elenco",
+    spread: 0.15,
+    segments: Object.fromEntries(
+      Object.entries(SEGMENT_NUMBERS).map(([kind, numbers]) => [kind, { ...numbers, multiplier: 1, hitPoints: ELENCO_HIT_POINTS[kind]?.hp ?? numbers.hitPoints }])
+    )
+  };
+  var CLASS_OF = { pistol: "pistol", rifle: "rifle" };
+  var TEAM_GAME_CALIBERS = Object.entries(team_game_default.calibers).map(([id, entry]) => ({
+    id,
+    points: entry.points,
+    penetration: entry.penetration,
+    class: CLASS_OF[entry.class] ?? "pistol",
+    skullRange: entry.skullRange,
+    pellets: "pellets" in entry ? entry.pellets : 1,
+    effectiveRangeMetres: entry.effectiveRangeMetres
+  }));
+  var TEAM_GAME_CALIBER_KEYS = Object.fromEntries(Object.entries(team_game_default.calibers).map(([id, entry]) => [entry.gameKey, id]));
+  var TEAM_GAME_RULES = { regionCost: team_game_default.regionCost, damageKeptPerBody: team_game_default.damageKeptPerBody, falloff: team_game_default.falloff };
+  var PHYSICAL_RULES = physical_default;
+  var { tissuePerCentimetre, torsoPath, regionFactor } = PHYSICAL_RULES;
+  var TORSO_RESISTANCE = torsoPath.fleshCentimetres * tissuePerCentimetre.flesh + torsoPath.boneCentimetres * tissuePerCentimetre.bone;
+  var HEAD_KINDS = /* @__PURE__ */ new Set(["head", "jaw", "neck"]);
+  var TORSO_KINDS = /* @__PURE__ */ new Set(["torso", "pelvis"]);
+  var segmentResistance = ({ kind, bodyCount, protection }) => {
+    if (TORSO_KINDS.has(kind)) return TORSO_RESISTANCE * regionFactor.torso * bodyCount + protection;
+    if (HEAD_KINDS.has(kind)) return TORSO_RESISTANCE * regionFactor.head + protection;
+    return TORSO_RESISTANCE * regionFactor.limb + protection;
+  };
+  var LIMB_BITS = {
+    armL: { severed: MISSING_BITS.armL, broken: MISSING_BITS.armLBroken },
+    armR: { severed: MISSING_BITS.armR, broken: MISSING_BITS.armRBroken },
+    legL: { severed: MISSING_BITS.legL, broken: MISSING_BITS.legLBroken },
+    legR: { severed: MISSING_BITS.legR, broken: MISSING_BITS.legRBroken }
+  };
+  var HEAD_RESISTANCE = segmentResistance({ kind: "head", bodyCount: 1, protection: 0 });
+  var gait_default = {
+    cascade: {
+      hip: 16,
+      spine: 11,
+      shoulder: 9,
+      elbow: 7,
+      leg: 14,
+      knee: 11,
+      head: 6
+    },
+    moves: {
+      idle: {
+        gait: 0,
+        freq: 0,
+        amp: 0,
+        knee: 0,
+        bob: 0,
+        lean: 0,
+        arm: 0,
+        elb: 0.12,
+        crouch: 0,
+        aim: 0,
+        turn: 0,
+        grip: 0.35
+      },
+      walk: {
+        gait: 1,
+        freq: 5.6,
+        amp: 0.42,
+        knee: 0.85,
+        bob: 0.035,
+        lean: 0.05,
+        arm: 0.42,
+        elb: 0.3,
+        crouch: 0,
+        aim: 0,
+        turn: 0,
+        grip: 0.4
+      },
+      run: {
+        gait: 1,
+        freq: 9.2,
+        amp: 0.72,
+        knee: 1.5,
+        bob: 0.06,
+        lean: 0.3,
+        arm: 0.85,
+        elb: 1.35,
+        crouch: 0,
+        aim: 0,
+        turn: 0,
+        grip: 1.1
+      },
+      crouch: {
+        gait: 1,
+        freq: 3.8,
+        amp: 0.3,
+        knee: 0.6,
+        bob: 0.02,
+        lean: 0.42,
+        arm: 0.15,
+        elb: 0.7,
+        crouch: 1,
+        aim: 0,
+        turn: 0,
+        grip: 0.8
+      },
+      aim: {
+        gait: 0,
+        freq: 0,
+        amp: 0,
+        knee: 0,
+        bob: 0,
+        lean: 0.06,
+        arm: 0,
+        elb: 0.2,
+        crouch: 0.25,
+        aim: 1,
+        turn: 0,
+        grip: 1.2
+      },
+      turn: {
+        gait: 0.5,
+        freq: 4.2,
+        amp: 0.14,
+        knee: 0.7,
+        bob: 0.012,
+        lean: 0.03,
+        arm: 0.12,
+        elb: 0.25,
+        crouch: 0,
+        aim: 0,
+        turn: 1,
+        grip: 0.4
+      }
+    },
+    poses: [
+      {
+        index: 0,
+        id: "walk",
+        name: {
+          "pt-BR": "anda"
+        }
+      },
+      {
+        index: 1,
+        id: "crawl",
+        name: {
+          "pt-BR": "rasteja"
+        }
+      },
+      {
+        index: 2,
+        id: "fallen",
+        name: {
+          "pt-BR": "ca\xEDdo"
+        }
+      },
+      {
+        index: 3,
+        id: "attack",
+        name: {
+          "pt-BR": "ataca"
+        }
+      },
+      {
+        index: 4,
+        id: "scream",
+        name: {
+          "pt-BR": "grito"
+        }
+      },
+      {
+        index: 5,
+        id: "crouch",
+        name: {
+          "pt-BR": "agachado"
+        }
+      },
+      {
+        index: 6,
+        id: "leap",
+        name: {
+          "pt-BR": "salto"
+        }
+      },
+      {
+        index: 7,
+        id: "eat",
+        name: {
+          "pt-BR": "comendo"
+        }
+      }
+    ],
+    walk: {
+      cadenceBase: 0.5,
+      cadencePerSpeed: 0.3,
+      stopBelowSpeed: 0.05,
+      maxSine: 0.9,
+      strideFactor: 4,
+      legLengthFactor: 0.9
+    }
+  };
+  var WALK = gait_default.walk;
+  var CASCADE = gait_default.cascade;
+  var TWO_PI = Math.PI * 2;
+  var MOVES = gait_default.moves;
+  var appearance_default = {
+    variance: {
+      height: {
+        gaussianSpread: 0.09,
+        min: 0.9,
+        max: 1.1
+      },
+      buildBands: [
+        {
+          below: 0.3,
+          base: 0.85,
+          range: 0.1
+        },
+        {
+          below: 0.8,
+          base: 0.95,
+          range: 0.13
+        },
+        {
+          base: 1.08,
+          range: 0.17
+        }
+      ],
+      buildSpeed: {
+        lean: 1.05,
+        heavy: 0.9
+      },
+      buildHealth: {
+        lean: 0.9,
+        heavy: 1.15
+      },
+      speedJitter: {
+        base: 0.92,
+        range: 0.16
+      },
+      wanderJitter: {
+        base: 0.8,
+        range: 0.4
+      },
+      runnerAgeClamp: 1,
+      variantCount: {
+        walker: 4,
+        runner: 3,
+        crawler: 2,
+        brute: 2
+      },
+      variantSeedBase: 7e3
+    },
+    civilianColors: [
+      "6D5A4A",
+      "4D5D6B",
+      "7A3B33",
+      "5B6B4A",
+      "8A7A5A",
+      "3E4A5C",
+      "6A4A6A",
+      "9A8A70",
+      "40403A"
+    ],
+    corpses: {
+      max: 400,
+      lifeSeconds: 900
+    }
+  };
+  var { variance } = appearance_default;
+  var palette_exports = {};
+  __export2(palette_exports, {
+    BAG_COLORS: () => BAG_COLORS,
+    BLOOD_COLORS: () => BLOOD_COLORS,
+    CAP_COLORS: () => CAP_COLORS,
+    DECAY_SKIN: () => DECAY_SKIN,
+    GRAY: () => GRAY,
+    HAIR_COLORS: () => HAIR_COLORS,
+    HAIR_STYLES_FEMALE: () => HAIR_STYLES_FEMALE,
+    HAIR_STYLES_MALE: () => HAIR_STYLES_MALE,
+    OLD_HAIR: () => OLD_HAIR,
+    PANTS_COLORS: () => PANTS_COLORS,
+    RED: () => RED,
+    SHOE_COLORS: () => SHOE_COLORS,
+    SKIN_DECAY_BLEND: () => SKIN_DECAY_BLEND,
+    SKIN_TONES: () => SKIN_TONES,
+    SLEEVES: () => SLEEVES,
+    TOP_COLORS: () => TOP_COLORS,
+    UNIFORM_PANTS: () => UNIFORM_PANTS,
+    UNIFORM_SHIRTS: () => UNIFORM_SHIRTS,
+    UNIFORM_SHOES: () => UNIFORM_SHOES
+  });
+  var SKIN_TONES = [15845797, 14724224, 13012066, 11039050, 9067066, 6175526];
+  var TOP_COLORS = [4878230, 9321275, 6113850, 5208643, 7040888, 4153146, 5917294, 9071162, 12104354, 2894896, 10111530, 3104099, 13216074, 8007242, 14210248, 3820138];
+  var PANTS_COLORS = [2896704, 2040360, 4866096, 5922662, 3820138, 6969920, 2767402];
+  var SLEEVES = ["short", "short", "long", "tank"];
+  var HAIR_STYLES_FEMALE = ["long", "long", "bun", "short", "afro", "bald"];
+  var HAIR_STYLES_MALE = ["short", "short", "buzz", "bald", "afro", "long"];
+  var CAP_COLORS = [9321275, 2894896, 3820138, 13216074];
+  var BAG_COLORS = [3820090, 5909028, 2896704];
+  var HAIR_COLORS = [1709072, 2760214, 3877920, 6965802, 11569744, 8006170];
+  var SHOE_COLORS = [1908514, 3811866, 12104872, 4856346];
+  var DECAY_SKIN = [13482920, 9740420, 8090698, 9206878];
+  var UNIFORM_SHIRTS = [4878230, 9321275, 6113850, 5208643, 7040888, 4153146, 5917294, 9071162];
+  var UNIFORM_PANTS = 2896704;
+  var UNIFORM_SHOES = 1908514;
+  var SKIN_DECAY_BLEND = [0.45, 0.65, 0.8, 0.88];
+  var GRAY = 4868678;
+  var RED = 8000012;
+  var BLOOD_COLORS = [10361618, 7214096, 4860440, 1840658];
+  var OLD_HAIR = 9078656;
+
+  // 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();
+      }
+    };
+  }
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=index.global.js.map