@adatechnology/game-crowd-three 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1086 @@
+// src/instances.ts
+import { INSTANCE_POSES, walkGait } from "@adatechnology/game-characters";
+import { MISSING, STATE } from "@adatechnology/game-crowd";
+
+// src/data/render.json
+var render_default = {
+  sources: {
+    agents: "jogo.js G 67098-67121 hordeRender: view cull (behind beyond 0.35\xB7d + 3 m once past \u221A30 m, nothing past 200 m), LOD [18, 55] m with 1.5 m of hysteresis, attack pose in at 1.6 m and out at 2.2 m, the pose by state, the bloater's swelling, the eye only with the skull and awake",
+    corpses: "jogo.js G 67122-67131 hordeRender: an agent's body on its variant at the near level within 18 m (else the middle), the fallen pose, the colour darkening 70% over the body's life, the last 60 s shrinking it; a body that was not an agent on the plain body batch",
+    civilians: "jogo.js G 70177-70184 npcRender: one baked body per survivor, a child 0.66 high and 0.75 wide, the bite showing as 0.3 of age",
+    batches: "jogo.js G 67079-67094 ZVAR, CB: each variant at 1, 0.5 and 0.28 of detail in batches of 160, 700 and 2600; the plain corpse batch at the middle body (BODY_LOD[1]) for 400; G 68469 PB: survivors baked at 0.8 in batches of 4"
+  },
+  numbers: {
+    lodDistances: [18, 55],
+    lodHysteresis: 1.5,
+    behindFrom: 30,
+    behindFactor: 0.35,
+    behindMargin: 3,
+    farCull: 200,
+    gaitMax: 1.4,
+    attackEnter: 2.56,
+    attackLeave: 4.84,
+    swell: 0.9,
+    swellPivot: 0.5,
+    ageBase: 0.75,
+    agePer: 0.08,
+    armBase: 1,
+    armPer: 0.4,
+    corpseNear: 18,
+    corpseFade: 60,
+    corpseDarken: 0.7,
+    corpseRise: 1.8,
+    corpseAgeBase: 0.8,
+    corpseAgeDark: 0.2,
+    childHeight: 0.66,
+    childBuild: 0.75,
+    bittenLook: 0.3,
+    civilianSkinStep: 0.25,
+    civilianBake: 0.8,
+    civilianBatch: 4
+  },
+  poses: {
+    dormant: "fallen",
+    airborne: "leap",
+    eating: "eat",
+    pileStep: "attack",
+    swing: "scream",
+    crawl: "crawl",
+    grab: "attack",
+    calling: "scream",
+    default: "walk",
+    corpse: "fallen",
+    civilian: "walk"
+  }
+};
+
+// src/instances.ts
+var CROWD_RENDER_DEFAULTS = {
+  sources: render_default.sources,
+  numbers: render_default.numbers,
+  poses: render_default.poses
+};
+var poseIndex = (pose) => INSTANCE_POSES.indexOf(pose);
+function createCrowdInstances(options) {
+  const N = { ...render_default.numbers, ...options.numbers };
+  const P = { ...render_default.poses, ...options.poses };
+  const pose = {
+    dormant: poseIndex(P.dormant),
+    airborne: poseIndex(P.airborne),
+    eating: poseIndex(P.eating),
+    pileStep: poseIndex(P.pileStep),
+    swing: poseIndex(P.swing),
+    crawl: poseIndex(P.crawl),
+    grab: poseIndex(P.grab),
+    calling: poseIndex(P.calling),
+    walk: poseIndex(P.default),
+    corpse: poseIndex(P.corpse),
+    civilian: poseIndex(P.civilian)
+  };
+  const [near, middle] = N.lodDistances;
+  const lodEdges = [near, middle];
+  const behindFrom = N.behindFrom;
+  const farSquared = N.farCull * N.farCull;
+  return {
+    numbers: N,
+    agents(Z, variants, frame, sink) {
+      const cx = frame.camera.x;
+      const cz = frame.camera.z;
+      const fx = -Math.sin(frame.viewYaw);
+      const fz = -Math.cos(frame.viewYaw);
+      const target = frame.target;
+      let written = 0;
+      for (let i = 0; i < Z.n; i++) {
+        const dx = Z.x[i] - cx;
+        const dz = Z.z[i] - cz;
+        const d2 = dx * dx + dz * dz;
+        if (d2 > behindFrom && dx * fx + dz * fz < -Math.sqrt(d2) * N.behindFactor - N.behindMargin) continue;
+        if (d2 > farSquared) continue;
+        if (frame.hidden?.(i)) continue;
+        let l = Z.lod[i];
+        const dd = Math.sqrt(d2);
+        while (l > 0 && dd < lodEdges[l - 1] - N.lodHysteresis) l--;
+        while (l < 2 && dd > lodEdges[l] + N.lodHysteresis) l++;
+        Z.lod[i] = l;
+        const sp = Z.renderSpeed[i];
+        const gait = Math.min(N.gaitMax, walkGait(sp, Z.height[i]));
+        const st = Z.state[i];
+        if (st === STATE.CHASE && target?.alive) {
+          const px = Z.x[i] - target.x;
+          const pz = Z.z[i] - target.z;
+          const p2 = px * px + pz * pz;
+          Z.attackPose[i] = p2 < (Z.attackPose[i] ? N.attackLeave : N.attackEnter) ? 1 : 0;
+        } else Z.attackPose[i] = 0;
+        const p = st === STATE.DORMANT ? pose.dormant : st === STATE.AIRBORNE ? pose.airborne : st === STATE.EATING ? pose.eating : st === STATE.PILE_STEP ? pose.pileStep : st === STATE.SWING ? pose.swing : Z.crawl[i] ? pose.crawl : st === STATE.GRAB || Z.attackPose[i] ? pose.grab : st === STATE.CALLING ? pose.calling : pose.walk;
+        const bb = st === STATE.SWELLING ? Z.build[i] * (1 + (N.swellPivot - Z.stateTimer[i]) * N.swell) : Z.build[i];
+        const eyeOn = !(Z.missing[i] & MISSING.SKULL);
+        const V = variants[Z.variant[i]];
+        sink(Z.variant[i], l, {
+          a: [Z.x[i], Z.z[i], Z.renderYaw[i], Z.phase[i]],
+          b: [Z.height[i] / V.s, bb / V.bulk, gait, p],
+          c: [Z.missing[i], N.ageBase + Z.age[i] * N.agePer, N.armBase + N.armPer * Z.arms[i], Z.skin[i]],
+          color: Z.color[i],
+          shade: 1,
+          eye: eyeOn && st !== STATE.DORMANT ? options.eyes[Z.type[i]] ?? null : null,
+          y: Z.y[i]
+        });
+        written++;
+      }
+      return written;
+    },
+    corpses(entries, variants, frame, life, sink, plain) {
+      const cx = frame.camera.x;
+      const cz = frame.camera.z;
+      for (const { age: t, data: C } of entries) {
+        const dark = Math.min(1, t / life);
+        const shade = 1 - dark * N.corpseDarken;
+        const fade = t > life - N.corpseFade ? (life - t) / N.corpseFade : 1;
+        const c = [C.missing, N.corpseAgeBase + dark * N.corpseAgeDark, 1, C.skin];
+        if (C.variant >= 0) {
+          const V = variants[C.variant];
+          const dx = C.x - cx;
+          const dz = C.z - cz;
+          const l = dx * dx + dz * dz < N.corpseNear * N.corpseNear ? 0 : 1;
+          sink(C.variant, l, { a: [C.x, C.z, C.yaw, C.seed], b: [C.height / V.s * fade, C.build / V.bulk, Math.min(1, t * N.corpseRise), pose.corpse], c, color: C.color, shade, eye: null, y: 0 });
+          continue;
+        }
+        plain({ a: [C.x, C.z, C.yaw, C.seed], b: [C.height * fade, C.build, Math.min(1, t * N.corpseRise), pose.corpse], c, color: C.color, shade, eye: null, y: 0 });
+      }
+    },
+    civilians(list, colorOf, sink) {
+      for (const n of list) {
+        if (n.state === "undead" || n.state === "gone" || n.state === "dead") continue;
+        const sp = Math.hypot(n.vx, n.vz);
+        const child = !!n.spec.child;
+        sink(n, {
+          a: [n.x, n.z, n.yaw, n.phase],
+          b: [child ? N.childHeight : 1, child ? N.childBuild : 1, Math.min(N.gaitMax, walkGait(sp, child ? N.childHeight : 1)), pose.civilian],
+          c: [0, n.biteTimer > 0 ? N.bittenLook : 0, 0, n.k * N.civilianSkinStep],
+          color: colorOf(n),
+          shade: 1,
+          eye: null,
+          y: 0
+        });
+      }
+    }
+  };
+}
+
+// src/renderer.ts
+import { variantDecay, variantSeed } from "@adatechnology/game-characters";
+import { LOD_BAKE, LOD_SEGMENTS, bakeBody, buildInstancedBody, createBodyBatch, createVariantBatches } from "@adatechnology/game-characters-three";
+var now = () => typeof performance === "undefined" ? Date.now() : performance.now();
+function createCrowdRenderer(three, options) {
+  const { crowd } = options;
+  const group = new three.Group();
+  group.name = "crowd";
+  const time = { value: 0 };
+  const eyes = crowd.pack.types.map((type) => type.eye ?? null);
+  const instances = createCrowdInstances({ eyes, ...options.numbers ? { numbers: options.numbers } : {}, ...options.poses ? { poses: options.poses } : {} });
+  const N = instances.numbers;
+  const variants = [];
+  const batches = [];
+  let plain = null;
+  const people = /* @__PURE__ */ new Map();
+  let bakeMs = 0;
+  const lodCounts = [0, 0, 0];
+  const shirt = new three.Color();
+  const eyeColors = /* @__PURE__ */ new Map();
+  const eyeOf = (hex) => {
+    let color = eyeColors.get(hex);
+    if (!color) eyeColors.set(hex, color = new three.Color(hex));
+    return color;
+  };
+  const push = (batch, instance) => {
+    if (!batch) return;
+    shirt.setHex(instance.color).multiplyScalar(instance.shade);
+    batch.push({ a: instance.a, b: instance.b, c: instance.c, color: shirt, ...instance.eye !== null ? { eye: eyeOf(instance.eye) } : {}, y: instance.y });
+  };
+  const typeOfVariant = [];
+  crowd.variantsOf.forEach((list, c) => list.forEach((g) => typeOfVariant[g] = c));
+  const baked = /* @__PURE__ */ new Set();
+  const ensurePlain = () => {
+    if (!plain) {
+      plain = createBodyBatch(three, options.plainBody ?? buildInstancedBody(three, { segments: LOD_SEGMENTS[1] }), { max: crowd.numbers.corpsesMax, castShadow: false, time });
+      group.add(plain.mesh);
+    }
+    return plain;
+  };
+  const bakeType = (c) => {
+    if (baked.has(c)) return;
+    baked.add(c);
+    const type = crowd.pack.types[c];
+    const name = options.typeName?.(type, c) ?? type.id;
+    const started = now();
+    crowd.variantsOf[c].forEach((g, v) => {
+      const decay = variantDecay(v);
+      const seed = variantSeed(c, v);
+      const bodies = LOD_BAKE.map((lod) => bakeBody(three, options.builders, { type: name, decay, seed }, lod));
+      const variant = { typeId: type.id, variant: v, seed, decay, s: bodies[0].s, bulk: bodies[0].bulk, verts: bodies.map((body) => body.verts), geometries: bodies.map((body) => body.geo) };
+      variants[g] = variant;
+      batches[g] = createVariantBatches(three, variant, time);
+      for (const batch of batches[g]) group.add(batch.mesh);
+    });
+    bakeMs += now() - started;
+  };
+  const bake = () => crowd.pack.types.forEach((_, c) => bakeType(c));
+  const bakeSeen = () => {
+    const Z = crowd.store;
+    for (let i = 0; i < Z.n; i++) if (!baked.has(Z.type[i])) bakeType(Z.type[i]);
+    for (const { data } of crowd.corpses.entries) if (data.variant >= 0 && !baked.has(typeOfVariant[data.variant])) bakeType(typeOfVariant[data.variant]);
+  };
+  const personBatch = (civilian) => {
+    const made = people.get(civilian.id);
+    if (made) return made;
+    const spec = options.civilians?.body(civilian);
+    if (!spec) return void 0;
+    const batch = createBodyBatch(three, bakeBody(three, options.builders, spec, N.civilianBake).geo, { max: N.civilianBatch, time });
+    people.set(civilian.id, batch);
+    group.add(batch.mesh);
+    return batch;
+  };
+  const all = () => [...batches.flatMap((set) => set ?? []), ...plain ? [plain] : [], ...people.values()];
+  return {
+    group,
+    instances,
+    bake,
+    update(dt, frame) {
+      bakeSeen();
+      time.value += dt;
+      for (const batch of all()) batch.begin();
+      instances.agents(crowd.store, variants, frame, (v, l, instance) => push(batches[v]?.[l], instance));
+      if (options.drawCorpses?.() !== false) instances.corpses(crowd.corpses.entries, variants, frame, crowd.numbers.corpseSeconds, (v, l, instance) => push(batches[v]?.[l], instance), (instance) => push(ensurePlain(), instance));
+      for (let l = 0; l < 3; l++) lodCounts[l] = batches.reduce((sum, set) => sum + (set?.[l]?.count ?? 0), 0);
+      const list = options.civilians?.list();
+      if (list) instances.civilians(list, options.civilians?.color ?? ((n) => n.spec.color ?? 8421504), (n, instance) => push(personBatch(n), instance));
+      for (const batch of all()) batch.end();
+    },
+    get lodCounts() {
+      return lodCounts;
+    },
+    get drawCalls() {
+      return all().filter((batch) => batch.count > 0).length;
+    },
+    get bakeMs() {
+      return bakeMs;
+    },
+    get variants() {
+      return variants;
+    },
+    dispose() {
+      for (const batch of all()) {
+        batch.mesh.geometry.dispose();
+        group.remove(batch.mesh);
+      }
+      variants.length = 0;
+      batches.length = 0;
+      baked.clear();
+      plain = null;
+      people.clear();
+    }
+  };
+}
+
+// src/herd-view.ts
+function createHerdView(three, options) {
+  const group = new three.Group();
+  group.name = "herd";
+  const drawn = /* @__PURE__ */ new Map();
+  const sky = [];
+  const build = (E) => {
+    const species = options.species(E.spec.species);
+    if (!species) return null;
+    const rig = options.drawer.build(species);
+    rig.root.position.set(E.x, 0, E.z);
+    if (E.dead) options.drawer.setVisualState?.(rig, "dead");
+    group.add(rig.root);
+    drawn.set(E, rig);
+    if (E.spec.sky) sky.push(E);
+    return rig;
+  };
+  return {
+    group,
+    update(dt) {
+      for (const E of options.herd.list) if (!drawn.has(E)) build(E);
+      const time = options.herd.time;
+      for (const [E, rig] of drawn) {
+        if (E.spec.sky) continue;
+        rig.root.position.set(E.x, 0, E.z);
+        rig.root.rotation.y = E.yaw;
+        options.drawer.animate(rig, { time, delta: dt, clip: E.clip });
+      }
+      sky.forEach((E, i) => {
+        const rig = drawn.get(E);
+        const U = options.flock?.birds[i];
+        if (!rig || !U) return;
+        rig.root.position.set(U.x, U.y, U.z);
+        rig.root.rotation.set(0, U.yaw, U.roll);
+        rig.root.visible = U.visible;
+        if (!U.visible) return;
+        rig.phase = U.wing;
+        for (const w of rig.wings) {
+          w.shoulder.rotation.y = 0;
+          w.elbow.rotation.y = 0;
+          w.shoulder.rotation.z = w.side * (0.18 + Math.sin(U.wing * 0.4) * 0.05);
+        }
+      });
+    },
+    get count() {
+      return drawn.size;
+    },
+    clear() {
+      for (const rig of drawn.values()) group.remove(rig.root);
+      drawn.clear();
+      sky.length = 0;
+    }
+  };
+}
+
+// src/audio/bank.ts
+import { DISTANCE_CURVES } from "@adatechnology/game-audio";
+var scream = {
+  id: "scream_hoarse",
+  bus: "voices",
+  order: "scream",
+  duration: [1, 1.4],
+  layers: [
+    {
+      source: { kind: "noise", offset: "random" },
+      filters: {
+        mode: "parallel",
+        bank: [
+          { type: "bandpass", q: 6, frequency: { from: 700 * 1.15, to: 700 * 0.8, curve: "linear", over: "duration" }, level: 1 },
+          { type: "bandpass", q: 8, frequency: { from: 1150 * 1.15, to: 1150 * 0.8, curve: "linear", over: "duration" }, level: 0.7 },
+          { type: "bandpass", q: 10, frequency: { from: 2600 * 1.15, to: 2600 * 0.8, curve: "linear", over: "duration" }, level: 0.35 }
+        ]
+      },
+      modulators: [{ target: "gain", wave: "square", rate: [31, 40], depth: 0.35 }],
+      envelope: [
+        [0, 0, "set"],
+        [0.06, 0.9, "linear"],
+        ["0.6d", 0.9, "set"],
+        ["1d", 1e-3, "exp", "fixed"]
+      ]
+    }
+  ],
+  falloff: DISTANCE_CURVES.game_scream,
+  sources: ["jogo:L62128-62142"]
+};
+var groanLayer = (base) => ({
+  source: {
+    kind: "osc",
+    wave: "sawtooth",
+    frequency: typeof base === "number" ? { from: base, to: base * 0.7, curve: "linear", over: "duration" } : { from: base, to: { ...base, scale: 0.7 }, curve: "linear", over: "duration" }
+  },
+  filters: { mode: "serial", bank: [{ type: "bandpass", q: 3, frequency: { set: typeof base === "number" ? base * 3 : { ...base, scale: 3 } } }] },
+  envelope: [
+    [0, 0, "set"],
+    [0.15, 0.25, "linear"],
+    ["1d", 1e-3, "exp", "fixed"]
+  ]
+});
+var groan = {
+  id: "groan",
+  bus: "voices",
+  order: "groan",
+  vars: { base: [95, 135], dur: [0.9, 1.5] },
+  duration: { param: "dur" },
+  layers: [groanLayer({ param: "base" })],
+  falloff: DISTANCE_CURVES.game_voice,
+  sources: ["jogo:L62143-62155 gemido"]
+};
+var runnerGroan = {
+  id: "runner_groan",
+  bus: "voices",
+  order: "groan",
+  vars: { dur: [0.9, 1.5] },
+  duration: { param: "dur" },
+  layers: [groanLayer(300)],
+  falloff: DISTANCE_CURVES.game_voice,
+  sources: ["jogo:L62143-62155 corredor"]
+};
+var call = (id, options) => ({
+  id,
+  bus: "world",
+  order: "calls",
+  duration: options.seconds,
+  tail: 0.02,
+  keepSilent: true,
+  layers: [
+    {
+      repeat: { count: options.count, spacing: options.spacing },
+      source: { kind: "osc", wave: options.wave, frequency: { from: options.frequency, to: options.frequency * options.drop, curve: "exp", over: "duration" } },
+      filters: { mode: "serial", bank: [{ type: "bandpass", frequency: { set: options.frequency * 1.2 }, q: 3 }] },
+      envelope: [
+        [0, 1e-4, "set", "fixed"],
+        [0.015, 1, "exp"],
+        ["1d", 1e-4, "exp", "fixed"]
+      ]
+    }
+  ],
+  falloff: DISTANCE_CURVES.animals,
+  sources: ["jogo:L66625-66639"]
+});
+var CROWD_SOUND_BANK = {
+  id: "crowd",
+  sounds: [
+    scream,
+    groan,
+    runnerGroan,
+    call("dog_bark", { count: 2, spacing: 0.22, seconds: 0.12, wave: "square", frequency: 520, drop: 0.6 }),
+    call("lapwing_call", { count: 3, spacing: 0.14, seconds: 0.09, wave: "square", frequency: 2400, drop: 0.6 }),
+    call("hen_cluck", { count: 4, spacing: 0.14, seconds: 0.09, wave: "square", frequency: 900, drop: 0.6 }),
+    call("cow_moo", { count: 1, spacing: 0.14, seconds: 1.2, wave: "sawtooth", frequency: 140, drop: 0.8 })
+  ]
+};
+var HERD_SOUND_IDS = { bark: "dog_bark", lapwing: "lapwing_call", cluck: "hen_cluck", moo: "cow_moo" };
+
+// src/bench/module.ts
+import { HERD_ROLES, STATE as STATE2, bindInfection, carrionCenter, createCivilians, createCrowd, createFlock, createHerd, createRng } from "@adatechnology/game-crowd";
+import { createPlayer } from "@adatechnology/game-player";
+
+// src/bench/locale.ts
+var EN = {
+  group: "Crowd",
+  name: "Crowd area",
+  mix: "Mixed (by weight)",
+  controls: {
+    count: "Agents",
+    type: "Type of the new ones",
+    night: "Night",
+    seed: "Seed",
+    spawn: "Add 100",
+    noise: "Noise here (80 m)",
+    hit: "Shoot the nearest in the head",
+    kill_all: "Kill all",
+    join: "Civilians join you",
+    flee: "Civilians run away",
+    herd: "Bring the animals",
+    materialize: "Bring 50 from the region",
+    push: "Push (break a grab)",
+    reset: "Start again"
+  },
+  hints: {
+    count: "The crowd grows or shrinks to this many, born 10 to 90 m from the area centre. Only the near ones think every frame (relevance bands).",
+    type: "The type of the agents added from now on; mixed draws them by the weights of the pack.",
+    night: "At night sight drops by 40%.",
+    noise: "A noise heard 80 m around you: the ones that hear it come.",
+    hit: "A headshot to the nearest agent: a body on the ground, blood through the room effects.",
+    join: "The civilians follow you; bitten, they turn after the bite time.",
+    flee: "The civilians run off along a path out of the area and are gone.",
+    herd: "A companion dog, hens, a lapwing, cows, a horse, a pig, a capybara, a carcass and the vultures over it.",
+    materialize: "The region model turns 50 of its numbers into agents near you; the far ones go back.",
+    push: "What holds you lets go after six pushes."
+  },
+  layers: { corpses: "Bodies on the ground", civilians: "Civilians", animals: "Animals" },
+  metrics: {
+    agents: "Agents",
+    drawn: "Drawn",
+    lod_near: "Near level",
+    lod_middle: "Middle level",
+    lod_far: "Far level",
+    draw_calls: "Draw calls",
+    bake_ms: "Bake",
+    active: "Thinking every frame",
+    kills: "Kills",
+    corpses: "Bodies",
+    civilians: "Civilians alive",
+    health: "Your health",
+    grabbed: "Grabbed",
+    message: "Last message"
+  },
+  scenarios: {
+    relevance: "Relevance: 500 agents, only the near ones every frame",
+    lod: "Level of detail with 1.5 m of hysteresis",
+    attack_pose: "Attack pose in at 1.6 m, out at 2.2 m",
+    corpse_darkens: "A body darkens and shrinks at the end of its life",
+    civilians_flee: "Civilians follow, then run away and are gone",
+    herd_calls: "The hen flees and clucks, the lapwing raises the alarm",
+    vultures: "The vultures circle the bodies",
+    infection: "Region numbers become agents and go back",
+    determinism: "The same seed, the same crowd"
+  },
+  messages: {
+    called: "A screamer called the crowd",
+    burst_hit: "Hit by a bloater burst",
+    swing_knock: "A brute knocked you down",
+    pounce_knock: "A leaper knocked you down",
+    migration: "A crowd is on the move",
+    door_broken: "A door gave way",
+    alarm: "A bird raises the alarm",
+    bark: "The dog is barking",
+    growl: "The dog is growling",
+    bitten: "A civilian was bitten",
+    turned: "A civilian turned",
+    died: "A civilian died"
+  },
+  yes: "yes",
+  no: "no"
+};
+var PT_BR = {
+  group: "Multid\xE3o",
+  name: "\xC1rea da multid\xE3o",
+  mix: "Misturado (pelo peso)",
+  controls: {
+    count: "Agentes",
+    type: "Tipo dos novos",
+    night: "Noite",
+    seed: "Semente",
+    spawn: "Mais 100",
+    noise: "Barulho aqui (80 m)",
+    hit: "Tiro na cabe\xE7a do mais perto",
+    kill_all: "Matar todos",
+    join: "Civis v\xEAm com voc\xEA",
+    flee: "Civis fogem",
+    herd: "Trazer os bichos",
+    materialize: "Trazer 50 da regi\xE3o",
+    push: "Empurrar (soltar-se)",
+    reset: "Recome\xE7ar"
+  },
+  hints: {
+    count: "A multid\xE3o cresce ou diminui at\xE9 esse n\xFAmero, nascendo de 10 a 90 m do centro da \xE1rea. S\xF3 os de perto pensam todo quadro (faixas de relev\xE2ncia).",
+    type: "O tipo dos agentes acrescentados daqui em diante; misturado sorteia pelos pesos do pacote.",
+    night: "\xC0 noite a vis\xE3o cai 40%.",
+    noise: "Um barulho ouvido a 80 m de voc\xEA: quem ouve vem.",
+    hit: "Um tiro na cabe\xE7a do agente mais perto: um corpo no ch\xE3o, sangue pelos efeitos da sala.",
+    join: "Os civis seguem voc\xEA; mordidos, viram depois do tempo da mordida.",
+    flee: "Os civis fogem por um caminho para fora da \xE1rea e somem.",
+    herd: "Um c\xE3o companheiro, galinhas, um quero-quero, vacas, um cavalo, um porco, uma capivara, uma carca\xE7a e os urubus sobre ela.",
+    materialize: "O modelo da regi\xE3o transforma 50 dos seus n\xFAmeros em agentes perto de voc\xEA; os de longe voltam.",
+    push: "Quem segura voc\xEA solta depois de seis empurr\xF5es."
+  },
+  layers: { corpses: "Corpos no ch\xE3o", civilians: "Civis", animals: "Bichos" },
+  metrics: {
+    agents: "Agentes",
+    drawn: "Desenhados",
+    lod_near: "N\xEDvel perto",
+    lod_middle: "N\xEDvel meio",
+    lod_far: "N\xEDvel longe",
+    draw_calls: "Chamadas de desenho",
+    bake_ms: "Cozimento",
+    active: "Pensando todo quadro",
+    kills: "Mortes",
+    corpses: "Corpos",
+    civilians: "Civis vivos",
+    health: "Sua vida",
+    grabbed: "Agarrado",
+    message: "\xDAltima mensagem"
+  },
+  scenarios: {
+    relevance: "Relev\xE2ncia: 500 agentes, s\xF3 os de perto todo quadro",
+    lod: "N\xEDvel de detalhe com 1,5 m de histerese",
+    attack_pose: "Pose de ataque entra a 1,6 m e sai a 2,2 m",
+    corpse_darkens: "O corpo escurece e encolhe no fim da vida",
+    civilians_flee: "Civis seguem, depois fogem e somem",
+    herd_calls: "A galinha foge e cacareja, o quero-quero d\xE1 o alarme",
+    vultures: "Os urubus circulam os corpos",
+    infection: "N\xFAmeros da regi\xE3o viram agentes e voltam",
+    determinism: "A mesma semente, a mesma multid\xE3o"
+  },
+  messages: {
+    called: "Um gritador chamou a multid\xE3o",
+    burst_hit: "Atingido pelo estouro de um inchado",
+    swing_knock: "Um brutamonte derrubou voc\xEA",
+    pounce_knock: "Um saltador derrubou voc\xEA",
+    migration: "Uma multid\xE3o est\xE1 migrando",
+    door_broken: "Uma porta cedeu",
+    alarm: "Um p\xE1ssaro d\xE1 o alarme",
+    bark: "O c\xE3o est\xE1 latindo",
+    growl: "O c\xE3o est\xE1 rosnando",
+    bitten: "Um civil foi mordido",
+    turned: "Um civil virou",
+    died: "Um civil morreu"
+  },
+  yes: "sim",
+  no: "n\xE3o"
+};
+var TEXT = { en: EN, "pt-BR": PT_BR };
+var crowdBenchTextOf = (locale) => TEXT[locale] ?? PT_BR;
+
+// src/bench/module.ts
+var CROWD_AREA_ID = "crowd_area";
+var CROWD_EFFECTS = {
+  blood: { effect: "blood_hit" },
+  limb: { effect: "dismember" },
+  cloud: { effect: "bloater_cloud" },
+  spark: { effect: "impact", param: "metal" },
+  dust: { effect: "impact", param: "concrete" }
+};
+var CAPACITY = 4e3;
+var FRAME = 1 / 30;
+var RING = [10, 90];
+var LOTS = { home: { x: -14, z: -14, w: 8, d: 10, house: true, front: 1 }, shop: { x: 8, z: -14, w: 10, d: 10, front: 1 } };
+var CIVILIANS = [
+  { id: "civilian_1", home: "home", color: 4090506 },
+  { id: "civilian_2", home: "home", color: 13672496, child: true },
+  { id: "civilian_3", home: "shop", color: 6969914 },
+  { id: "civilian_4", home: "shop", color: 9058906 }
+];
+var WAY_OUT = [
+  [0, 4],
+  [30, 4],
+  [60, 20]
+];
+var FARM = [
+  ["dog", 2, 3, { companion: true }],
+  ["cat", 12, -6],
+  ["chicken", -8, 4],
+  ["chicken", -8.5, 5],
+  ["chicken", -7.5, 4.6],
+  ["southern_lapwing", 8, 5],
+  ["cow", -20, -10],
+  ["cow", -24, -12],
+  ["horse", -26, -4],
+  ["pig", -14, -16],
+  ["capybara", 18, 14],
+  ["cow", -18, -24, { dead: true }],
+  ["vulture", 0, 0],
+  ["vulture", 0, 0],
+  ["vulture", 0, 0]
+];
+var messageText = (text, id) => text.messages[id] ?? id;
+function createCrowdTestModule(options) {
+  const locale = options.locale ?? "pt-BR";
+  const text = crowdBenchTextOf(locale);
+  const effects = options.effects ?? CROWD_EFFECTS;
+  const [cx, cz] = options.center ?? [0, -45];
+  const settings = { count: options.startCount ?? 0, type: "mix", night: false, seed: options.seed ?? 1 };
+  const layers = { corpses: true, civilians: true, animals: true };
+  let host = null;
+  let three = null;
+  let renderer = null;
+  let herdView = null;
+  let lastMessage = "";
+  let pending = {};
+  let last = null;
+  const offs = [];
+  const build = (seed) => {
+    const player = createPlayer({ seed });
+    const crowd = createCrowd({ pack: options.pack, seed, capacity: CAPACITY, target: player });
+    const civilians = createCivilians(crowd, { people: CIVILIANS.map((c) => ({ ...c })), buildings: LOTS });
+    const herd = createHerd(crowd, { view: () => ({ x: player.state.x, z: player.state.z }) });
+    const flock = createFlock({ count: 0, mode: "carrion" });
+    const model = options.infection?.create() ?? null;
+    const spot = createRng(seed + 7);
+    const binding = model ? bindInfection(crowd, model, { place: () => [cx + (spot() - 0.5) * 40, cz - 20 - spot() * 40], civilians, regionOf: () => options.infection.region }) : null;
+    const place = () => {
+      const a = spot() * Math.PI * 2;
+      const r = RING[0] + spot() * (RING[1] - RING[0]);
+      const type = settings.type === "mix" ? -1 : crowd.typeIndex(settings.type);
+      return crowd.spawn(cx + Math.cos(a) * r, cz + Math.sin(a) * r, type);
+    };
+    return { crowd, player, civilians, herd, flock, vultures: 0, binding, model, place };
+  };
+  let world = build(settings.seed);
+  const wire = () => {
+    for (const off of offs.splice(0)) off();
+    const { crowd, herd, civilians } = world;
+    offs.push(crowd.on("sound", (e) => void host?.audio?.play({ sound: e.sound, volume: e.volume, position: e.position })));
+    offs.push(herd.on("sound", (e) => void host?.audio?.play({ sound: HERD_SOUND_IDS[e.sound] ?? e.sound, volume: e.volume, position: e.position })));
+    offs.push(crowd.on("effect", (e) => playEffect(e)));
+    offs.push(crowd.on("message", (e) => void (lastMessage = messageText(text, e.id))));
+    offs.push(herd.on("message", (e) => void (lastMessage = messageText(text, e.id))));
+    offs.push(civilians.on("bitten", () => void (lastMessage = text.messages.bitten)));
+    offs.push(civilians.on("turned", () => void (lastMessage = text.messages.turned)));
+    offs.push(civilians.on("died", () => void (lastMessage = text.messages.died)));
+    offs.push(crowd.on("kill", (e) => host?.log(`crowd kill: ${e.type}`, { agent: e.agent, headshot: e.headshot })));
+  };
+  const playEffect = (e) => {
+    const map = effects[e.effect];
+    if (!map || !host?.effects) return;
+    host.effects.play({ effect: map.effect, point: e.point, ...map.param !== void 0 ? { param: map.param } : {}, ...e.amount !== void 0 ? { scale: Math.max(0.3, Math.min(2, e.amount / 30)) } : {} });
+  };
+  const fit = () => {
+    const { crowd } = world;
+    while (crowd.store.n < settings.count && world.place() >= 0) {
+    }
+    while (crowd.store.n > settings.count) crowd.remove(crowd.store.n - 1);
+  };
+  const bringHerd = () => {
+    const animals = options.animals;
+    if (!animals || world.herd.list.length) return;
+    for (const [id, dx, dz, extra] of FARM) {
+      const species = animals.species(id);
+      if (!species) continue;
+      world.herd.add({ ...HERD_ROLES[id], ...extra, species: id, x: cx + dx, z: cz + 30 + dz, walkHz: species.walkHz, runHz: species.runHz, size: animals.size(species) });
+    }
+    world.vultures = world.herd.list.filter((E) => E.spec.sky).length;
+    world.flock = createFlock({ count: world.vultures, mode: "carrion" });
+    herdView?.clear();
+    herdView = null;
+  };
+  const reset = () => {
+    world.binding?.unbind();
+    renderer?.dispose();
+    if (renderer) host?.scene?.remove(renderer.group);
+    renderer = null;
+    herdView?.clear();
+    if (herdView) host?.scene?.remove(herdView.group);
+    herdView = null;
+    world = build(settings.seed);
+    wire();
+    fit();
+    lastMessage = "";
+  };
+  const view = () => {
+    const camera = host?.camera;
+    if (!camera?.position) return null;
+    const Vector3 = host?.THREE?.Vector3;
+    if (camera.getWorldDirection && Vector3) {
+      const look = camera.getWorldDirection(new Vector3());
+      return { x: camera.position.x, z: camera.position.z, yaw: Math.atan2(-look.x, -look.z) };
+    }
+    return { x: camera.position.x, z: camera.position.z, yaw: camera.rotation?.y ?? 0 };
+  };
+  const ensureDrawing = () => {
+    if (!host || !three) return;
+    const scene = host.scene;
+    if (!renderer && options.builders) {
+      const bodies = options.civilianBodies ?? [];
+      renderer = createCrowdRenderer(three, {
+        crowd: world.crowd,
+        builders: options.builders(three),
+        ...options.typeName ? { typeName: options.typeName } : {},
+        drawCorpses: () => layers.corpses,
+        ...bodies.length ? { civilians: { list: () => layers.civilians ? world.civilians.list : [], body: (n) => bodies[n.k % bodies.length] } } : {}
+      });
+      scene.add(renderer.group);
+    }
+    if (!herdView && options.animals?.drawer && world.herd.list.length) {
+      herdView = createHerdView(three, { herd: world.herd, flock: world.flock, drawer: options.animals.drawer(three), species: options.animals.species });
+      scene.add(herdView.group);
+    }
+  };
+  const frame = (dt) => {
+    const { crowd, player, civilians, herd, flock } = world;
+    const here = view();
+    const speed = here && last && dt > 0 ? Math.hypot(here.x - last.x, here.z - last.z) / dt : 0;
+    if (here) {
+      player.state.x = here.x;
+      player.state.z = here.z;
+    }
+    player.update(dt, { forward: speed > 0.2 ? 1 : 0, run: speed > 3.4, yaw: here?.yaw ?? 0, pressed: pending }, { crowd: crowd.asPlayerCrowd() });
+    pending = {};
+    if (here) {
+      player.state.x = here.x;
+      player.state.z = here.z;
+      last = { x: here.x, z: here.z };
+    }
+    crowd.updateTrail(dt);
+    civilians.update(dt);
+    if (herd.list.length) {
+      herd.update(dt);
+      const carcass = herd.list.find((E) => E.dead);
+      flock.update(herd.time, dt, carrionCenter(crowd.corpses.entries.map((e) => e.data), carcass ? [carcass.x, carcass.z] : null), [player.state.x, player.state.z]);
+    }
+    crowd.update(dt, { viewYaw: here?.yaw ?? 0, nightFactor: settings.night ? 1 : 0 });
+    crowd.updateCorpses(dt);
+    ensureDrawing();
+    if (renderer && (crowd.store.n || crowd.corpses.count || civilians.list.length)) {
+      renderer.update(dt, { camera: { x: player.state.x, z: player.state.z }, viewYaw: here?.yaw ?? 0, target: { x: player.state.x, z: player.state.z, alive: player.state.alive } });
+    }
+    if (herdView) {
+      herdView.group.visible = layers.animals;
+      herdView.update(dt);
+    }
+  };
+  const hitNearest = () => {
+    const { crowd, player } = world;
+    const Z = crowd.store;
+    let best = -1;
+    let bd = Infinity;
+    for (let i = 0; i < Z.n; i++) {
+      const d = Math.hypot(Z.x[i] - player.state.x, Z.z[i] - player.state.z);
+      if (d < bd) [best, bd] = [i, d];
+    }
+    if (best >= 0) crowd.damage(best, { region: 0, amount: 200, distance: bd, cut: 0, caliber: null });
+  };
+  const onChange = (change) => {
+    if (change.kind === "layer") {
+      if (change.id in layers) layers[change.id] = change.on;
+      return;
+    }
+    if (change.kind === "action") {
+      const id2 = change.id;
+      if (id2 === "spawn") {
+        settings.count = Math.min(CAPACITY, world.crowd.store.n + 100);
+        host?.bench?.patch("count", { value: settings.count });
+        fit();
+      } else if (id2 === "noise") world.crowd.emitNoise(world.player.state.x, world.player.state.z, 80);
+      else if (id2 === "hit") hitNearest();
+      else if (id2 === "kill_all") for (let i = world.crowd.store.n - 1; i >= 0; i--) world.crowd.kill(i);
+      else if (id2 === "join") for (const n of world.civilians.list) world.civilians.join(n.id);
+      else if (id2 === "flee") for (const n of world.civilians.list) world.civilians.flee(n.id, WAY_OUT.map(([x, z]) => [cx + x, cz + 40 + z]));
+      else if (id2 === "herd") bringHerd();
+      else if (id2 === "materialize" && world.binding && options.infection) world.binding.materialize(options.infection.region, 50);
+      else if (id2 === "push") pending = { ...pending, push: true };
+      else if (id2 === "reset") reset();
+      return;
+    }
+    const { id, value } = change;
+    if (id === "count" && typeof value === "number") {
+      settings.count = value;
+      fit();
+    } else if (id === "type" && typeof value === "string") settings.type = value;
+    else if (id === "night" && typeof value === "boolean") settings.night = value;
+    else if (id === "seed" && typeof value === "number" && value !== settings.seed) {
+      settings.seed = value;
+      reset();
+    }
+  };
+  const typeOptions = () => [{ id: "mix", name: text.mix }, ...options.pack.types.map((type) => ({ id: type.id, name: options.typeLabel?.(type, locale) ?? type.id }))];
+  const controls = () => [
+    { kind: "number", id: "count", name: text.controls.count, hint: text.hints.count, min: 0, max: 3e3, step: 100, default: settings.count },
+    { kind: "choice", id: "type", name: text.controls.type, hint: text.hints.type, options: typeOptions(), default: "mix" },
+    { kind: "boolean", id: "night", name: text.controls.night, hint: text.hints.night, default: false },
+    { kind: "number", id: "seed", name: text.controls.seed, min: 1, max: 9999, step: 1, default: settings.seed },
+    { kind: "action", id: "spawn", name: text.controls.spawn },
+    { kind: "action", id: "noise", name: text.controls.noise, hint: text.hints.noise },
+    { kind: "action", id: "hit", name: text.controls.hit, hint: text.hints.hit },
+    { kind: "action", id: "kill_all", name: text.controls.kill_all },
+    { kind: "action", id: "join", name: text.controls.join, hint: text.hints.join },
+    { kind: "action", id: "flee", name: text.controls.flee, hint: text.hints.flee },
+    ...options.animals ? [{ kind: "action", id: "herd", name: text.controls.herd, hint: text.hints.herd }] : [],
+    ...options.infection ? [{ kind: "action", id: "materialize", name: text.controls.materialize, hint: text.hints.materialize }] : [],
+    { kind: "action", id: "push", name: text.controls.push, hint: text.hints.push },
+    { kind: "action", id: "reset", name: text.controls.reset }
+  ];
+  const benchLayers = () => [
+    { id: "corpses", name: text.layers.corpses },
+    { id: "civilians", name: text.layers.civilians },
+    { id: "animals", name: text.layers.animals }
+  ];
+  const metrics = () => [
+    { id: "agents", name: text.metrics.agents, digits: 0, max: CAPACITY, read: () => world.crowd.store.n },
+    { id: "drawn", name: text.metrics.drawn, digits: 0, read: () => renderer ? renderer.lodCounts[0] + renderer.lodCounts[1] + renderer.lodCounts[2] : 0 },
+    { id: "lod_near", name: text.metrics.lod_near, digits: 0, read: () => renderer?.lodCounts[0] ?? 0 },
+    { id: "lod_middle", name: text.metrics.lod_middle, digits: 0, read: () => renderer?.lodCounts[1] ?? 0 },
+    { id: "lod_far", name: text.metrics.lod_far, digits: 0, read: () => renderer?.lodCounts[2] ?? 0 },
+    { id: "draw_calls", name: text.metrics.draw_calls, digits: 0, read: () => renderer?.drawCalls ?? 0 },
+    { id: "bake_ms", name: text.metrics.bake_ms, unit: "ms", digits: 0, read: () => renderer?.bakeMs ?? 0 },
+    { id: "active", name: text.metrics.active, digits: 0, read: () => world.crowd.stats.bands[0] },
+    { id: "kills", name: text.metrics.kills, digits: 0, read: () => world.crowd.stats.kills },
+    { id: "bodies", name: text.metrics.corpses, digits: 0, read: () => world.crowd.corpses.count },
+    { id: "civilians_alive", name: text.metrics.civilians, digits: 0, read: () => world.civilians.list.filter((n) => n.state !== "dead" && n.state !== "undead" && n.state !== "gone").length },
+    { id: "health", name: text.metrics.health, digits: 0, read: () => Math.max(0, world.player.state.health) },
+    { id: "grabbed", name: text.metrics.grabbed, read: () => world.player.state.grabbedBy >= 0 ? text.yes : text.no },
+    { id: "message", name: text.metrics.message, read: () => lastMessage }
+  ];
+  const fresh = (seed = 1, capacity = 600) => {
+    const player = createPlayer({ seed });
+    return { crowd: createCrowd({ pack: options.pack, seed, capacity, flow: { clock: () => 0 }, target: player }), player };
+  };
+  const run = (crowd, seconds) => {
+    for (let t = 0; t < seconds; t += FRAME) {
+      crowd.update(FRAME);
+      crowd.updateCorpses(FRAME);
+    }
+  };
+  const eyes = options.pack.types.map((type) => type.eye ?? null);
+  const sizes = Array.from({ length: options.pack.types.reduce((sum, type) => sum + (type.variants ?? 1), 0) }, () => ({ s: 1.7, bulk: 1 }));
+  const drawOnce = (crowd, player) => {
+    const out = [];
+    createCrowdInstances({ eyes }).agents(crowd.store, sizes, { camera: { x: player.state.x, z: player.state.z }, viewYaw: 0, target: { x: player.state.x, z: player.state.z, alive: true } }, (_v, level, instance) => out.push({ level, pose: instance.b[3] }));
+    return out;
+  };
+  const scenarios = () => [
+    {
+      id: "crowd_relevance",
+      name: text.scenarios.relevance,
+      run: ({ expect }) => {
+        const { crowd } = fresh(3);
+        const spot = createRng(3);
+        for (let k = 0; k < 500; k++) crowd.spawn((spot() - 0.5) * 600, (spot() - 0.5) * 600);
+        run(crowd, 1);
+        const [near, , mid, far] = crowd.stats.bands;
+        expect(crowd.store.n === 500, "500 agents", { n: crowd.store.n });
+        expect(near < 50 && mid + far > 400, "few think every frame, most are far and slow", { bands: [...crowd.stats.bands] });
+      }
+    },
+    {
+      id: "crowd_lod",
+      name: text.scenarios.lod,
+      run: ({ expect }) => {
+        const { crowd, player } = fresh(1, 4);
+        player.state.x = 0;
+        player.state.z = 0;
+        const i = crowd.spawn(0, -17, 0);
+        const levels = [];
+        for (const z of [-17, -19, -19.6, -17.5, -16]) {
+          crowd.store.z[i] = z;
+          levels.push(drawOnce(crowd, player)[0].level);
+        }
+        expect(levels.join() === "0,0,1,1,0", "in at 19.5 m, back under 16.5 m", { levels });
+      }
+    },
+    {
+      id: "crowd_attack_pose",
+      name: text.scenarios.attack_pose,
+      run: ({ expect }) => {
+        const { crowd, player } = fresh(1, 4);
+        const i = crowd.spawn(0, -1.5, 0);
+        crowd.store.state[i] = STATE2.CHASE;
+        const poses = [];
+        for (const z of [-1.5, -2, -2.3, -1.9]) {
+          crowd.store.z[i] = z;
+          poses.push(drawOnce(crowd, player)[0].pose);
+        }
+        expect(poses.join() === "3,3,0,0", "the attack pose holds to 2.2 m and comes back under 1.6 m", { poses });
+      }
+    },
+    {
+      id: "crowd_corpse_darkens",
+      name: text.scenarios.corpse_darkens,
+      run: ({ expect }) => {
+        const { crowd, player } = fresh(1, 4);
+        crowd.kill(crowd.spawn(0, -5, 0));
+        const life = crowd.numbers.corpseSeconds;
+        crowd.updateCorpses(life / 2);
+        const shades = [];
+        const heights = [];
+        const take = (_v, _l, instance) => {
+          shades.push(instance.shade);
+          heights.push(instance.b[0]);
+        };
+        const instances = createCrowdInstances({ eyes });
+        const frameOf = { camera: { x: player.state.x, z: player.state.z }, viewYaw: 0 };
+        instances.corpses(crowd.corpses.entries, sizes, frameOf, life, take, (i) => take(-1, 1, i));
+        crowd.updateCorpses(life / 2 - 30);
+        instances.corpses(crowd.corpses.entries, sizes, frameOf, life, take, (i) => take(-1, 1, i));
+        expect(Math.abs(shades[0] - 0.65) < 1e-9, "half its life: 65% of the colour", { shades });
+        expect(Math.abs(heights[1] / heights[0] - 0.5) < 1e-6, "30 s before the end: half its height", { heights });
+      }
+    },
+    {
+      id: "crowd_civilians_flee",
+      name: text.scenarios.civilians_flee,
+      run: ({ expect }) => {
+        const { crowd, player } = fresh(2, 4);
+        player.state.x = 0;
+        player.state.z = 6;
+        const civilians = createCivilians(crowd, { people: [{ id: "c", home: "home" }], buildings: LOTS });
+        civilians.join("c");
+        for (let t = 0; t < 10; t += 0.05) civilians.update(0.05);
+        const c = civilians.get("c");
+        expect(Math.hypot(c.x - 0, c.z - 6) < 2.5, "it follows", { x: c.x, z: c.z });
+        civilians.flee("c", [[5, 6], [10, 6]]);
+        for (let t = 0; t < 20; t += 0.05) civilians.update(0.05);
+        expect(c.state === "gone", "it ran off and is gone", { state: c.state });
+      }
+    },
+    {
+      id: "crowd_herd_calls",
+      name: text.scenarios.herd_calls,
+      run: ({ expect }) => {
+        const { crowd } = fresh(4, 4);
+        const herd = createHerd(crowd);
+        const hen = herd.add({ ...HERD_ROLES.chicken, species: "chicken", x: 20, z: 0, walkHz: 2.2, runHz: 4, size: 0.4 });
+        herd.add({ ...HERD_ROLES.southern_lapwing, species: "southern_lapwing", x: 5, z: 0, walkHz: 2.5, runHz: 1.6, size: 0.35 });
+        crowd.spawn(21.5, 0, 0);
+        const sounds = [];
+        herd.on("sound", (e) => sounds.push(HERD_SOUND_IDS[e.sound] ?? e.sound));
+        for (let f = 0; f < 40; f++) herd.update(0.05);
+        expect(sounds.includes("hen_cluck") && sounds.includes("lapwing_call"), "the hen clucks, the lapwing calls", { sounds });
+        expect(hen.x < 20, "the hen ran", { x: hen.x });
+      }
+    },
+    {
+      id: "crowd_vultures",
+      name: text.scenarios.vultures,
+      run: ({ expect }) => {
+        const centre = carrionCenter([{ x: 0, z: 0 }, { x: 3, z: 0 }, { x: 0, z: 3 }], null);
+        const vultures = createFlock({ count: 3, mode: "carrion" });
+        vultures.update(10, 0.05, centre, [0, 0]);
+        const r = vultures.birds.map((U) => Math.hypot(U.x - centre[0], U.z - centre[1]));
+        expect(r.every((d, i) => Math.abs(d - (7 + i * 2)) < 1e-9), "each at its radius over the centre of the bodies", { r });
+      }
+    },
+    ...options.infection ? [
+      {
+        id: "crowd_infection",
+        name: text.scenarios.infection,
+        run: ({ expect }) => {
+          const infection = options.infection;
+          const model = infection.create();
+          const { crowd } = fresh(6, 64);
+          const binding = bindInfection(crowd, model, { place: (_r, seed, k) => [seed % 100 - 50 + k * 0.01, 500 + k] });
+          const before = infection.active?.(model);
+          const born = binding.materialize(infection.region, 10);
+          crowd.update(0.1);
+          const back = binding.giveBack(infection.region);
+          expect(born.length > 0 && back === born.length && crowd.store.n === 0, "brought out, given back", { born: born.length, back });
+          if (before !== void 0) expect(infection.active(model) === before, "the region keeps its numbers", { before, after: infection.active(model) });
+          binding.unbind();
+        }
+      }
+    ] : [],
+    {
+      id: "crowd_determinism",
+      name: text.scenarios.determinism,
+      run: ({ expect }) => {
+        const trace = (seed) => {
+          const { crowd } = fresh(seed, 40);
+          for (let k = 0; k < 30; k++) crowd.spawn(k % 6 * 3 - 8, -10 - Math.floor(k / 6) * 3);
+          run(crowd, 3);
+          return Array.from({ length: crowd.store.n }, (_, i) => `${crowd.store.x[i].toFixed(4)},${crowd.store.z[i].toFixed(4)}`).join(";");
+        };
+        expect(trace(9) === trace(9), "the same seed gives the same crowd");
+        expect(trace(9) !== trace(10), "another seed gives another");
+      }
+    }
+  ];
+  wire();
+  fit();
+  const module = {
+    id: CROWD_AREA_ID,
+    name: text.name,
+    group: text.group,
+    get crowd() {
+      return world.crowd;
+    },
+    get player() {
+      return world.player;
+    },
+    get renderer() {
+      return renderer;
+    },
+    items: () => [],
+    area: () => ({ placements: [], view: { eye: [0, 1.7, 6], target: [cx, 1.2, cz] } }),
+    controls: () => controls(),
+    layers: () => benchLayers(),
+    metrics: () => metrics(),
+    scenarios: () => scenarios(),
+    attach(lent) {
+      host = lent;
+      three = lent.THREE;
+      last = null;
+      lent.audio?.register?.(CROWD_SOUND_BANK);
+      const off = lent.bench?.onChange(onChange);
+      const offFrame = lent.onFrame(frame);
+      return () => {
+        off?.();
+        offFrame();
+        if (renderer) lent.scene.remove(renderer.group);
+        if (herdView) lent.scene.remove(herdView.group);
+        renderer?.dispose();
+        renderer = null;
+        herdView = null;
+        host = null;
+      };
+    }
+  };
+  return module;
+}
+export {
+  CROWD_AREA_ID,
+  CROWD_EFFECTS,
+  CROWD_RENDER_DEFAULTS,
+  CROWD_SOUND_BANK,
+  HERD_SOUND_IDS,
+  createCrowdInstances,
+  createCrowdRenderer,
+  createCrowdTestModule,
+  createHerdView,
+  crowdBenchTextOf
+};
+//# sourceMappingURL=index.js.map