@adatechnology/game-crowd 0.0.0-stage → 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,1128 @@
+import { CorpseLedger } from '@adatechnology/game-characters';
+
+var numbers = {
+	capacity: 6000,
+	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
+};
+var defaults = {
+	numbers: numbers
+};
+
+/** Occupancy codes of a grid cell (G 62162: 0 free, 1 solid, 2 low wall that can be climbed, 3 open door, 4 glass; 5 closed door, G 63816). */
+declare const CELL: {
+    readonly FREE: 0;
+    readonly SOLID: 1;
+    readonly LOW_WALL: 2;
+    readonly OPEN_DOOR: 3;
+    readonly GLASS: 4;
+    readonly CLOSED_DOOR: 5;
+};
+type NavGridOptions = {
+    /** Side of the square world in metres, centred on the origin (default 768, the game's world). */
+    readonly size?: number;
+    /** Cell side in metres (default 0.5). */
+    readonly cell?: number;
+    /** Fill a solid border of `borderWidth` m and `borderHeight` m around the world, as the game does (default true). */
+    readonly border?: boolean;
+};
+/**
+ * The navigation and collision grid of the game (G 62158-62170): a square world of cells with an occupancy code and a height. Agents, the player,
+ * the flow field and line of sight all read it. Buildings write it with `fillRect`.
+ */
+type NavGrid = {
+    readonly size: number;
+    readonly half: number;
+    readonly cell: number;
+    /** Cells per side. */
+    readonly n: number;
+    readonly occ: Uint8Array;
+    readonly occH: Float32Array;
+    cellOf(x: number, z: number): number;
+    /** Solid for a body at height `y` (default 0.5): outside the world, or an occupied cell that is not an open door and is taller than `y`. */
+    solidAt(x: number, z: number, y?: number): boolean;
+    /** The occupancy code at (x, z), -1 outside. */
+    cellKind(x: number, z: number): number;
+    fillRect(x0: number, z0: number, x1: number, z1: number, kind: number, height: number): void;
+    /** Blocked for a walking agent: outside, or anything but free and open door (G 66826 `zBlocked`). */
+    blocked(x: number, z: number): boolean;
+    /** Nothing solid and taller than 1.5 m between the two points, sampled every 0.5 m (G 66828 `losClear`). */
+    losClear(x0: number, z0: number, x1: number, z1: number): boolean;
+};
+declare function createNavGrid(options?: NavGridOptions): NavGrid;
+
+type Door = {
+    readonly x: number;
+    readonly z: number;
+    /** The leaf runs along `x` (front or back wall) or `z`. */
+    readonly axis: 'x' | 'z';
+    readonly width: number;
+    hp: number;
+    hpMax: number;
+    open: boolean;
+    broken: boolean;
+    planks: number;
+    readonly rect: readonly [number, number, number, number];
+    /** Whatever the game hangs on it (the building it belongs to). */
+    readonly data?: unknown;
+};
+type DoorEventMap = {
+    sound: {
+        sound: 'wood';
+        volume: number;
+        position: [number, number, number];
+    };
+    noise: {
+        x: number;
+        z: number;
+        radius: number;
+    };
+    effect: {
+        effect: 'dust';
+        point: [number, number, number];
+        color: number;
+    };
+    broken: {
+        door: number;
+    };
+};
+type DoorEventName = keyof DoorEventMap;
+type DoorNumbers = {
+    /** Hit points of a door (G 63803 `PORTA_VIDA`). */
+    readonly doorHp: number;
+    /** Hit points each plank adds (G 63803 `TABUA_VIDA`). */
+    readonly plankHp: number;
+    readonly height: number;
+    readonly thickness: number;
+    readonly soundChance: number;
+    readonly soundVolume: number;
+    readonly breakVolume: number;
+    readonly breakNoise: number;
+};
+declare const DOOR_DEFAULTS: DoorNumbers;
+type Doors = {
+    readonly list: readonly Door[];
+    /** The door index at a grid cell, -1 for none. */
+    at(cell: number): number;
+    add(x: number, z: number, axis: 'x' | 'z', width: number, data?: unknown): number;
+    /** Opens or closes: the cells become passable (3) or a closed door (5). A broken door stays open. */
+    set(index: number, open: boolean): void;
+    /** An agent hits a closed door (G 64044 `doorHit`): the 30% knock, planks giving way, and the door breaking open. */
+    hit(index: number, damage: number): void;
+    /** Nails a plank on (each adds `plankHp`). */
+    plank(index: number): void;
+    on<K extends DoorEventName>(event: K, listener: (event: DoorEventMap[K]) => void): () => void;
+};
+/** The doors of the game's buildings on a grid (G 63796-63816 `DOORS`, `doorAt`, `addDoor`, `setDoor`; G 64044 `doorHit`). */
+declare function createDoors(grid: NavGrid, options: {
+    random: () => number;
+    numbers?: Partial<DoorNumbers>;
+}): Doors;
+
+/**
+ * The agents as a struct of arrays (G 66717 `Z`, ZMAX 6000): one typed array per field, the same types as the game so the floats round the same way.
+ * The names are the game's in English; `armHp` and `legHp` hold two values per agent (left, right).
+ */
+declare const createStore: (capacity: number) => {
+    n: number;
+    capacity: number;
+    x: Float32Array<ArrayBuffer>;
+    z: Float32Array<ArrayBuffer>;
+    vx: Float32Array<ArrayBuffer>;
+    vz: Float32Array<ArrayBuffer>;
+    yaw: Float32Array<ArrayBuffer>;
+    phase: Float32Array<ArrayBuffer>;
+    type: Uint8Array<ArrayBuffer>;
+    age: Uint8Array<ArrayBuffer>;
+    outfit: Uint8Array<ArrayBuffer>;
+    height: Float32Array<ArrayBuffer>;
+    build: Float32Array<ArrayBuffer>;
+    chaseSpeed: Float32Array<ArrayBuffer>;
+    wanderSpeed: Float32Array<ArrayBuffer>;
+    hp: Float32Array<ArrayBuffer>;
+    hpMax: Float32Array<ArrayBuffer>;
+    headHp: Float32Array<ArrayBuffer>;
+    armHp: Float32Array<ArrayBuffer>;
+    legHp: Float32Array<ArrayBuffer>;
+    missing: Uint16Array<ArrayBuffer>;
+    helmet: Uint8Array<ArrayBuffer>;
+    state: Uint8Array<ArrayBuffer>;
+    stateTimer: Float32Array<ArrayBuffer>;
+    lost: Float32Array<ArrayBuffer>;
+    attackTimer: Float32Array<ArrayBuffer>;
+    band: Uint8Array<ArrayBuffer>;
+    next: Float32Array<ArrayBuffer>;
+    wx: Float32Array<ArrayBuffer>;
+    wz: Float32Array<ArrayBuffer>;
+    crawl: Uint8Array<ArrayBuffer>;
+    limp: Uint8Array<ArrayBuffer>;
+    color: Uint32Array<ArrayBuffer>;
+    skin: Float32Array<ArrayBuffer>;
+    alertIn: Float32Array<ArrayBuffer>;
+    cooldown: Float32Array<ArrayBuffer>;
+    y: Float32Array<ArrayBuffer>;
+    floor: Uint8Array<ArrayBuffer>;
+    floorLocked: Uint8Array<ArrayBuffer>;
+    vy: Float32Array<ArrayBuffer>;
+    abilityTimer: Float32Array<ArrayBuffer>;
+    eaten: Uint8Array<ArrayBuffer>;
+    stuck: Float32Array<ArrayBuffer>;
+    stepCell: Int32Array<ArrayBuffer>;
+    burn: Float32Array<ArrayBuffer>;
+    hunts: Int8Array<ArrayBuffer>;
+    named: Int8Array<ArrayBuffer>;
+    dvx: Float32Array<ArrayBuffer>;
+    dvz: Float32Array<ArrayBuffer>;
+    steering: Uint8Array<ArrayBuffer>;
+    renderYaw: Float32Array<ArrayBuffer>;
+    renderSpeed: Float32Array<ArrayBuffer>;
+    pause: Float32Array<ArrayBuffer>;
+    lod: Uint8Array<ArrayBuffer>;
+    variant: Uint8Array<ArrayBuffer>;
+    attackPose: Uint8Array<ArrayBuffer>;
+    arms: Float32Array<ArrayBuffer>;
+};
+type CrowdStore = ReturnType<typeof createStore>;
+/** The one-per-agent fields (G 66733 `FIELDS`): what a removal copies from the last agent. */
+declare const AGENT_FIELDS: readonly ["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"];
+
+/** What an agent is doing (G 66724 and 67180-67183): the store keeps the number. */
+declare const STATE: {
+    readonly WANDER: 0;
+    readonly CHASE: 1;
+    readonly GRAB: 2;
+    readonly STUNNED: 3;
+    readonly CALLING: 4;
+    readonly AIRBORNE: 5;
+    readonly DORMANT: 6;
+    readonly SWELLING: 7;
+    readonly SWING: 8;
+    readonly EATING: 9;
+    readonly PILE_STEP: 10;
+    readonly SEEKING_SOUND: 12;
+};
+/** Body regions of a hit (G 67012): 0 head, 1 torso, 2 left arm, 3 right arm, 4 left leg, 5 right leg. */
+type Region = 0 | 1 | 2 | 3 | 4 | 5;
+/**
+ * Missing parts as bits (G 67010-67045): 1 skull, 2 left arm off, 4 right arm off, 8 left leg off, 16 right leg off, 32 left arm broken, 64 right arm broken,
+ * 128 left leg broken, 256 right leg broken, 512 jaw.
+ */
+declare const MISSING: {
+    readonly SKULL: 1;
+    readonly ARM_L: 2;
+    readonly ARM_R: 4;
+    readonly LEG_L: 8;
+    readonly LEG_R: 16;
+    readonly ARM_L_BROKEN: 32;
+    readonly ARM_R_BROKEN: 64;
+    readonly LEG_L_BROKEN: 128;
+    readonly LEG_R_BROKEN: 256;
+    readonly JAW: 512;
+};
+/**
+ * The type traits: the special moves of a type, read in the game's order. A type without a trait does not have the move. Every number is the game's
+ * (`jogo.js` G 67180-67430, the Bestiário table 3.1 and 12.7).
+ */
+type CrowdTraits = {
+    /** Jumps a low obstacle in the way while chasing (car, yard wall) up to `maxHeight` m (runner, leaper). */
+    readonly vaultsLow?: {
+        readonly maxHeight: number;
+        readonly minRise: number;
+        readonly clearance: number;
+        readonly speedFactor: number;
+    };
+    /** Pounce from `min` to `max` m in line of sight: cooldown, flight time, speed cap, the vertical speeds and the knock-down on landing (leaper). */
+    readonly pounce?: {
+        readonly min: number;
+        readonly max: number;
+        readonly cooldown: number;
+        readonly time: number;
+        readonly speedCap: number;
+        readonly lift: number;
+        readonly liftHigh: number;
+        readonly highAbove: number;
+        readonly landRange: number;
+        readonly knock: number;
+    };
+    /** A heavy swing: chance per attack, wind-up, reach and knock-down (brute). */
+    readonly heavySwing?: {
+        readonly chance: number;
+        readonly windUp: number;
+        readonly range: number;
+        readonly knock: number;
+    };
+    /** Multiplies the damage on doors (brute 3). */
+    readonly doorDamage?: number;
+    /** Seconds stunned by a heavy hit (default `numbers.hitStun`; brute 0.25). */
+    readonly hitStun?: number;
+    /** Only hears: goes to the source of a sound and hits whatever it meets on the way, other agents too (blind). */
+    readonly soundSeeker?: {
+        readonly arrive: number;
+        readonly loseChase: number;
+        readonly hitRadius2: number;
+    };
+    /** Calls the crowd: wind-up, radius, cooldown, the boost it gives the target, and running from the fight afterwards (screamer). */
+    readonly caller?: {
+        readonly range: number;
+        readonly windUp: number;
+        readonly radius: number;
+        readonly cooldown: number;
+        readonly boost: number;
+        readonly fleeAbove: number;
+        readonly fleeRange: number;
+    };
+    /** Sets the target on fire on a hit (charred). */
+    readonly burns?: {
+        readonly seconds: number;
+    };
+    /** Loses a share of its health the first time it enters water (charred 0.7). */
+    readonly waterWeak?: {
+        readonly keep: number;
+        readonly cloud: number;
+    };
+    /** Waits under water and pulls the target down (drowned). */
+    readonly submerged?: {
+        readonly depth: number;
+        readonly wake: number;
+        readonly swim: number;
+        readonly surface: number;
+    };
+    /** Plays dead and wakes close or behind the target, then sprints for a while (stalker). */
+    readonly ambush?: {
+        readonly chance: number;
+        readonly wake: number;
+        readonly wakeBehind: number;
+        readonly behindCos: number;
+        readonly sprint: number;
+        readonly sprintSeconds: number;
+        readonly slow: number;
+    };
+    /** Swells and bursts close to the target: blinds and marks it with a scent (bloater). */
+    readonly burst?: {
+        readonly range: number;
+        readonly swell: number;
+        readonly radius: number;
+        readonly blind: number;
+        readonly scent: number;
+        readonly noiseNear: number;
+        readonly noise: number;
+        readonly cloudColor: number;
+        readonly bloodColor: number;
+        readonly bloodDry: number;
+    };
+    /** Eats corpses: search radius, reach, seconds, how many, what it gains (devourer). */
+    readonly eatsCorpses?: {
+        readonly max: number;
+        readonly search: number;
+        readonly reach: number;
+        readonly seconds: number;
+        readonly grabRange: number;
+        readonly health: number;
+        readonly grow: number;
+        readonly rest: number;
+        readonly retry: number;
+        readonly defend: number;
+        readonly approach: number;
+    };
+    /** Follows the target's blood trail and leads agents of the type `leads` along (sniffer). */
+    readonly tracker?: {
+        readonly range: number;
+        readonly leads: string;
+        readonly max: number;
+        readonly leadRadius: number;
+    };
+    /** Never older than this age index (runner: recent at most). */
+    readonly maxAge?: number;
+    /** The groan sound id (runner `runner_groan`; default `groan`). */
+    readonly voice?: string;
+    /** How much it adds to the target's panic (runner 2.5). */
+    readonly panicWeight?: number;
+    /** Pulls the target into water when it grabs there (drowned). */
+    readonly drownGrab?: boolean;
+    /** Body colour and skin override at birth (charred, drowned). */
+    readonly color?: number;
+    readonly skin?: number;
+};
+/** One type of agent (a zombie type, a cow, a civilian). The undead pack (`undeadCrowdTypes`) gives the 13 types of the game. */
+type CrowdType = {
+    readonly id: string;
+    /** Weight in the draw of an agent without a forced type (0: never drawn). */
+    readonly weight: number;
+    readonly health: number;
+    readonly speed: {
+        readonly wander: number;
+        readonly chase: number;
+    };
+    readonly damage: number;
+    /** Chance per attack to grab (and bite). */
+    readonly bite: number;
+    readonly multipliers: {
+        readonly head: number;
+        readonly torso: number;
+        readonly arms: number;
+        readonly legs: number;
+    };
+    /** Metres. */
+    readonly perception: {
+        readonly sight: number;
+        readonly hearing: number;
+        readonly smell: number;
+    };
+    readonly crawls?: boolean;
+    /** Height multiplier (brute 1.42). */
+    readonly scale?: number;
+    /** Build multiplier (bloater 1.35; a scaled type without one is 1.3). */
+    readonly build?: number;
+    /** Body variants of the type for the renderer (walker 4, runner 3, crawler and brute 2, others 1). */
+    readonly variants?: number;
+    readonly eye?: number;
+    readonly traits?: CrowdTraits;
+};
+/** The age of a body (G IDADES): its share, and what it does to speed, health, limbs and senses. */
+type CrowdAge = {
+    readonly id: string;
+    readonly p: number;
+    readonly speed: number;
+    readonly health: number;
+    readonly limb: number;
+    readonly sight: number;
+    readonly hearing: number;
+    readonly blood: number;
+    readonly bloodColor: number;
+    readonly dryColor: number;
+};
+/** What a body wears (G ROUPAS): its share, the vest against pistol and rifle classes, a helmet, a limb factor and the colour. */
+type CrowdOutfit = {
+    readonly id: string;
+    readonly p: number;
+    readonly vest?: {
+        readonly pistol: number;
+        readonly rifle: number;
+    };
+    readonly helmet?: boolean;
+    readonly limb?: number;
+    readonly color: number | null;
+};
+/** Everything the crowd draws a body from. */
+type CrowdPack = {
+    readonly types: readonly CrowdType[];
+    readonly ages: readonly CrowdAge[];
+    readonly outfits: readonly CrowdOutfit[];
+    /** Hit points of the segments, only for dismembering (G `SEG`). */
+    readonly segments: {
+        readonly head: number;
+        readonly arm: number;
+        readonly leg: number;
+    };
+    /** Clothes colours of the outfits without one (G `CIVIL_COR`). */
+    readonly palette: readonly number[];
+};
+/** The calibre of a projectile hit: its class (pistol or rifle, for vests and helmets), the skull distance (1: any) and an id. */
+type CrowdCaliber = {
+    readonly id: string;
+    readonly class: 'pistol' | 'rifle';
+    readonly skull: number;
+};
+type CrowdHit = {
+    readonly region: Region;
+    readonly amount: number;
+    readonly distance: number;
+    readonly cut?: number;
+    readonly caliber?: CrowdCaliber | null;
+};
+type CrowdDamageResult = {
+    readonly died: boolean;
+    readonly headshot?: boolean;
+};
+/**
+ * Who the crowd hunts. `game-player`'s `Player` is one as it is; a game with its own player writes a small object with the same names.
+ * Reads: `state`. Writes: the verbs, and `state.burnTimer`, `state.blind`, `state.scentTimer`, `state.screamBoost`.
+ */
+interface CrowdTarget {
+    readonly state: {
+        x: number;
+        z: number;
+        y: number;
+        floor: number;
+        alive: boolean;
+        turned: boolean;
+        crouch: boolean;
+        bleeding: number;
+        scentTimer: number;
+        screamBoost: number;
+        grabbedBy: number;
+        blind: number;
+        burnTimer: number;
+        /** The body's yaw; the view looks the other way (`yaw - π`). */
+        yaw: number;
+    };
+    grab(by: number, noJaw?: boolean, drown?: boolean): void;
+    hurt(amount: number, by?: number): void;
+    knock(seconds: number): void;
+    release(): void;
+}
+type CrowdSoundId = 'groan' | 'runner_groan' | 'scream_hoarse' | 'step' | 'impact' | 'flesh' | 'wood' | (string & {});
+type CrowdEffectId = 'spark' | 'blood' | 'limb' | 'cloud' | 'dust' | (string & {});
+type CrowdMessageId = 'called' | 'burst_hit' | 'swing_knock' | 'pounce_knock' | 'migration' | 'door_broken' | (string & {});
+type CrowdEventMap = {
+    sound: {
+        sound: CrowdSoundId;
+        volume: number;
+        position: [number, number, number];
+        distance: number;
+    };
+    effect: {
+        effect: CrowdEffectId;
+        point: [number, number, number];
+        agent?: number;
+        region?: number;
+        severed?: boolean;
+        radius?: number;
+        color?: number;
+        amount?: number;
+        died?: boolean;
+        age?: number;
+    };
+    message: {
+        id: CrowdMessageId;
+        seconds: number;
+        type?: string;
+    };
+    spawn: {
+        agent: number;
+        type: string;
+    };
+    alert: {
+        agent: number;
+    };
+    kill: {
+        agent: number;
+        type: string;
+        headshot: boolean;
+        x: number;
+        z: number;
+    };
+    remove: {
+        agent: number;
+        moved: number;
+    };
+    scream: {
+        agent: number;
+        x: number;
+        z: number;
+    };
+};
+type CrowdEventName = keyof CrowdEventMap;
+
+type CrowdNumbers = typeof defaults.numbers;
+type CrowdBand = {
+    readonly max: number;
+    readonly dt: number;
+};
+/** The game's numbers; `bands[3].max` is `Infinity` (JSON keeps it as null). */
+declare const CROWD_DEFAULTS: {
+    readonly sources: Readonly<Record<string, string>>;
+    readonly bands: readonly CrowdBand[];
+    readonly numbers: CrowdNumbers;
+};
+/** A body on the ground (G 67062 `CP`). */
+type Corpse = {
+    readonly x: number;
+    readonly z: number;
+    readonly yaw: number;
+    readonly height: number;
+    readonly build: number;
+    readonly missing: number;
+    readonly color: number;
+    /** Body variant of the renderer, -1 for a body that was not an agent (a civilian). */
+    readonly variant: number;
+    readonly skin: number;
+    readonly seed: number;
+    readonly named: number;
+};
+/** A custom move: runs on every decision tick after the timed states and before the moves on the target; `true` means it took care of the movement. */
+type CrowdPlugin = {
+    readonly id: string;
+    ability?(crowd: Crowd, i: number, context: {
+        d: number;
+        dx: number;
+        dz: number;
+        tdt: number;
+        band: number;
+        alive: boolean;
+    }): boolean;
+};
+/** A migration: `count` agents every `every` s (the first after `numbers.migrationFirst`), born in the box at (x, z) and walking to `goal`. */
+type MigrationOptions = {
+    readonly every: number;
+    readonly count: number;
+    readonly x: number;
+    readonly z: number;
+    readonly width: number;
+    readonly depth: number;
+    readonly goal: readonly [number, number];
+};
+type CrowdOptions = {
+    readonly pack: CrowdPack;
+    readonly random?: () => number;
+    readonly seed?: number;
+    readonly capacity?: number;
+    readonly grid?: NavGrid;
+    readonly doors?: Doors;
+    /** Water at (x, z): the drowned swim, the charred lose health (the game's `POOL`). */
+    readonly water?: (x: number, z: number) => boolean;
+    readonly numbers?: Partial<CrowdNumbers>;
+    readonly bands?: readonly CrowdBand[];
+    /** Flow field: half window in cells (192), and the clock its time budget reads (default `performance.now`; pass `() => 0` to finish every field in one frame). */
+    readonly flow?: {
+        readonly radius?: number;
+        readonly clock?: () => number;
+    };
+    readonly plugins?: readonly CrowdPlugin[];
+    readonly target?: CrowdTarget | null;
+};
+type CrowdView = {
+    readonly x: number;
+    readonly z: number;
+    readonly yaw: number;
+    readonly far: number;
+};
+type CrowdUpdateContext = {
+    readonly target?: CrowdTarget | null;
+    /** 0 day, 1 night: sight drops by 40% at night. */
+    readonly nightFactor?: number;
+    /** Where the flow field converges (the target by default; the foot of a ladder when the target is on a roof). */
+    readonly flowTarget?: readonly [number, number];
+    /** Where the viewer looks (yaw: forward is `(-sin, -cos)`); the stalker wakes when the target turns its back. Default: the target's view. */
+    readonly viewYaw?: number;
+};
+type Crowd = {
+    readonly store: CrowdStore;
+    readonly pack: CrowdPack;
+    readonly grid: NavGrid;
+    readonly doors: Doors;
+    readonly corpses: CorpseLedger<Corpse>;
+    readonly numbers: CrowdNumbers;
+    readonly stats: {
+        bands: [number, number, number, number];
+        slots: number;
+        kills: number;
+        heads: number;
+    };
+    /** Height of the bodies piled per grid cell. */
+    readonly pile: Float32Array;
+    /** How many agents are steps of a pile now. */
+    pileCount(): number;
+    readonly trail: {
+        x: number;
+        z: number;
+        t: number;
+    }[];
+    /** Global variant index of each type's variants (G 67079 `ZVAR_OF`). */
+    readonly variantsOf: readonly (readonly number[])[];
+    target: CrowdTarget | null;
+    /** The stream every draw takes (the behaviours share it, in the game's order). */
+    readonly random: () => number;
+    /** Emits a `sound` event, as the crowd's own (for the behaviours). */
+    sound(id: string, volume: number, x: number, y: number, z: number, distance: number): void;
+    /** Emits an `effect` event, as the crowd's own (for the behaviours). */
+    effect(payload: CrowdEventMap['effect']): void;
+    typeIndex(id: string): number;
+    spawn(x: number, z: number, type?: number): number;
+    remove(i: number): void;
+    update(dt: number, context?: CrowdUpdateContext): void;
+    emitNoise(x: number, z: number, radius: number): void;
+    damage(i: number, hit: CrowdHit): CrowdDamageResult;
+    kill(i: number, headshot?: boolean): void;
+    /** The blood trail of the target, for the trackers (G 67238 `trailUpdate`). */
+    updateTrail(dt: number, target?: CrowdTarget | null): void;
+    updateCorpses(dt: number): void;
+    /** Keeps the count near `target` from the edge, removes the excess out of sight and sends a migration now and then (G 67158). */
+    updatePopulation(dt: number, view: CrowdView, options?: {
+        readonly target?: number;
+        readonly migration?: MigrationOptions | null;
+    }): void;
+    /** Spawns one agent `minD` to `maxD` m from the target, out of the view (G 67141 `spawnAway`). */
+    spawnAway(minD: number, maxD: number, view: CrowdView): number;
+    /** A blast at the base of a pile undoes it (G 67227 `pileBlast`). */
+    pileBlast(x: number, z: number, radius: number): void;
+    /** The agent hunts something else than the target (a civilian): `game-crowd` civilians set it. */
+    setHunt(hunt: ((i: number, tdt: number) => boolean) | null): void;
+    /** The chase speed of agent `i` now (the stalker's sprint, the drowned in water; G 67343 `zChaseSpeed`). */
+    chaseSpeed(i: number): number;
+    /** The interface `game-player` uses to push, cut and be held by the agents. */
+    asPlayerCrowd(): PlayerCrowdLike;
+    on<K extends CrowdEventName>(event: K, listener: (event: CrowdEventMap[K]) => void): () => void;
+};
+/** The same shape as `game-player`'s `PlayerCrowd` (structural, no dependency). */
+type PlayerCrowdLike = {
+    count(): number;
+    active(i: number): boolean;
+    x(i: number): number;
+    z(i: number): number;
+    y(i: number): number;
+    floor(i: number): number;
+    chasing(i: number): boolean;
+    down(i: number): boolean;
+    panicWeight(i: number): number;
+    hold(i: number, x: number, z: number, k: number, lookX: number, lookZ: number): void;
+    stun(i: number, seconds: number, vx: number, vz: number): void;
+    chase(i: number, cooldown: number): void;
+    damage(i: number, hit: {
+        region: number;
+        amount: number;
+        distance: number;
+        cut: number;
+    }): void;
+};
+/**
+ * The crowd: a literal port of the team game's horde (`jogo.js` G 66714-67430). One struct of arrays, relevance bands R0-R3 with hysteresis, perception
+ * by sight, hearing and smell, the sliced flow field, the spatial hash, separation, six attack slots, chain alerts, doors, piles against walls, the
+ * abilities as type traits, corpses, the blood trail and the population. Every draw on `random` is in the game's order.
+ */
+declare function createCrowd(options: CrowdOptions): Crowd;
+
+/** Deterministic mulberry32 generator; returns floats in [0, 1). */
+declare function createRng(seed: number): () => number;
+
+/** A building the civilians walk between: its rectangle, whether it is a house (it has a gate), and the side its front faces (-1: toward -z). */
+type CivilianBuilding = {
+    readonly x: number;
+    readonly z: number;
+    readonly w: number;
+    readonly d: number;
+    readonly house?: boolean;
+    readonly front: -1 | 1;
+};
+type CivilianSpec = {
+    readonly id: string;
+    /** The building name it lives in. */
+    readonly home: string;
+    readonly child?: boolean;
+    readonly color?: number;
+    /** `[hour, building]`: from that hour, for one hour, it walks to that building. */
+    readonly routine?: readonly (readonly [number, string])[];
+    /** In a group it follows this civilian when that one is in the group too, else the target. */
+    readonly leader?: string;
+    /** How close it keeps to whom it follows (2.2 m; the game's child keeps 1.2). */
+    readonly followDistance?: number;
+};
+type CivilianState = 'home' | 'walking' | 'group' | 'fleeing' | 'gone' | 'dead' | 'undead';
+type Civilian = {
+    readonly id: string;
+    readonly spec: CivilianSpec;
+    readonly k: number;
+    x: number;
+    z: number;
+    yaw: number;
+    phase: number;
+    vx: number;
+    vz: number;
+    hp: number;
+    state: CivilianState;
+    path: [number, number][];
+    pathIndex: number;
+    /** Seconds left to turn after a bite (0: not bitten). */
+    biteTimer: number;
+    attackTimer: number;
+    fear: number;
+    /** The building it is going to (or is at). */
+    goal: string;
+    stuckTimer: number;
+    /** The agent it turned into. */
+    agent: number;
+};
+type CivilianNumbers = {
+    readonly hpAdult: number;
+    readonly hpChild: number;
+    readonly childOffset: number;
+    readonly sightSquared: number;
+    readonly leaveDistance: number;
+    readonly attackRange: number;
+    readonly attackEvery: number;
+    readonly biteFactor: number;
+    readonly biteSeconds: number;
+    readonly fearAfterHit: number;
+    readonly nearMessage: number;
+    readonly fearRange: number;
+    readonly fearSpeed: number;
+    readonly walkSpeed: number;
+    readonly childSpeed: number;
+    readonly bittenSpeed: number;
+    readonly groupRunBeyond: number;
+    readonly groupRunSpeed: number;
+    readonly fleeSpeed: number;
+    readonly childFleeFactor: number;
+    readonly stuckSeconds: number;
+    readonly arrive: number;
+    readonly probe: number;
+    readonly whiskers: readonly number[];
+    readonly doorProbe: number;
+    readonly steer: number;
+    readonly bodyHeight: number;
+    readonly patrolChance: number;
+    readonly childHeight: number;
+    readonly childBuild: number;
+    readonly cadenceBase: number;
+    readonly cadencePerSpeed: number;
+    readonly inside: number;
+    readonly doorInside: number;
+    readonly doorOutside: number;
+    readonly gate: number;
+    readonly sidewalk: number;
+    readonly houseOffset: number;
+};
+/** The game's numbers (`jogo.js` G 69960-70175). */
+declare const CIVILIAN_DEFAULTS: CivilianNumbers;
+type CivilianEventMap = {
+    bitten: {
+        id: string;
+        near: boolean;
+    };
+    died: {
+        id: string;
+        cause: 'attacked';
+    };
+    turned: {
+        id: string;
+        agent: number;
+    };
+    gone: {
+        id: string;
+    };
+};
+type CivilianEventName = keyof CivilianEventMap;
+type CivilianOptions = {
+    readonly people: readonly CivilianSpec[];
+    readonly buildings: Readonly<Record<string, CivilianBuilding>>;
+    /** The hour of the day now (0-24), for the routines. */
+    readonly hour?: () => number;
+    /** The crowd type a bitten civilian turns into (default the first type). */
+    readonly turnInto?: number;
+    /** The waypoints of a building (G 69967 `pontos`): inside, the door from inside and outside, the gate of a house, the sidewalk. */
+    readonly waypoints?: (building: CivilianBuilding) => [number, number][];
+    readonly numbers?: Partial<CivilianNumbers>;
+};
+type Civilians = {
+    readonly list: readonly Civilian[];
+    get(id: string): Civilian | undefined;
+    /** Moves the civilians, lets the agents hunt them, bites, deaths and turning (G 70144 `npcUpdate`, G 70042 `npcZombies`). */
+    update(dt: number): void;
+    /** Joins the target's group: follows its leader or the target. */
+    join(id: string): void;
+    /** Leaves along a path of points; at the end it is `gone`. */
+    flee(id: string, path: readonly (readonly [number, number])[]): void;
+    /** The route between two buildings (G 69974 `rota`): the points of one, the street crossing, the points of the other reversed. */
+    route(from: string, to: string): [number, number][];
+    on<K extends CivilianEventName>(event: K, listener: (event: CivilianEventMap[K]) => void): () => void;
+};
+/**
+ * Civilians on a crowd: a literal port of the team game's survivors on the block (`jogo.js` G 69960-70175: `pontos`, `rota`, `npcZombies`,
+ * `zChaseNpc`, `npcMorre`, `npcVira`, `npcMove`, `npcUpdate`). They keep a routine by the hour, run home when an agent is near, follow a leader in a
+ * group, leave along a path, open doors on the way; agents within 10 m that are closer to them than to the target hunt them, bite, and a bitten one
+ * turns after `biteSeconds`. No names, lines, radio or diary: those are the game's, through the events.
+ */
+declare function createCivilians(crowd: Crowd, options: CivilianOptions): Civilians;
+
+/** What an animal does besides wandering and fleeing; each is optional, an animal without one only wanders and flees. */
+type HerdRole = {
+    /** Wanders within this many metres of home (8). */
+    readonly range?: number;
+    /** Flees from the target closer than this and from agents closer than `fear·1.5 + 2` (5; 0 never flees). */
+    readonly fear?: number;
+    /** Calls when it flees (the hen): sound, noise radius, cooldown. */
+    readonly fleeCall?: {
+        readonly sound: string;
+        readonly noise: number;
+        readonly cooldown: number;
+    };
+    /** Alarm when the target comes within `range` (the lapwing): flies for `fly` s. */
+    readonly alarm?: {
+        readonly range: number;
+        readonly sound: string;
+        readonly noise: number;
+        readonly cooldown: number;
+        readonly fly: number;
+    };
+    /** Now and then calls loud (the cow): chance per second, sound, noise, cooldown. */
+    readonly call?: {
+        readonly chance: number;
+        readonly sound: string;
+        readonly noise: number;
+        readonly cooldown: number;
+    };
+    /** Barks at agents within `bark` m and growls at agents within `growl` m when it is the target's companion (the dog). */
+    readonly guard?: {
+        readonly bark: number;
+        readonly barkNoise: number;
+        readonly barkCooldown: number;
+        readonly growl: number;
+        readonly growlCooldown: number;
+        readonly sound: string;
+    };
+};
+type HerdAnimalSpec = HerdRole & {
+    /** The species id (any registry: `game-animals-species` has the 13 of the deliveries). */
+    readonly species: string;
+    readonly x: number;
+    readonly z: number;
+    /** The species' gait rates and its size (`game-animals` `quadrupedLayout(body).size`, `birdSize(body)`). */
+    readonly walkHz: number;
+    readonly runHz: number;
+    readonly size: number;
+    /** Follows 2.2 m behind the target (the companion dog). */
+    readonly companion?: boolean;
+    /** A carcass: it does not move (the vultures circle it). */
+    readonly dead?: boolean;
+    /** A bird of the sky (the vulture): only the flock moves it. */
+    readonly sky?: boolean;
+};
+type HerdAnimal = {
+    readonly index: number;
+    readonly spec: HerdAnimalSpec;
+    x: number;
+    z: number;
+    yaw: number;
+    homeX: number;
+    homeZ: number;
+    range: number;
+    fear: number;
+    clip: 'idle' | 'walk' | 'run';
+    timer: number;
+    targetX: number;
+    targetZ: number;
+    fly: number;
+    cooldown: number;
+    walkSpeed: number;
+    runSpeed: number;
+    companion: boolean;
+    dead: boolean;
+    /** The nearest agent seen in the last look (index and distance), refreshed about a quarter of the time. */
+    near: readonly [number, number] | null | undefined;
+};
+type HerdEventMap = {
+    sound: {
+        sound: string;
+        volume: number;
+        position: [number, number, number];
+        distance: number;
+        animal: number;
+    };
+    noise: {
+        x: number;
+        z: number;
+        radius: number;
+        animal: number;
+    };
+    message: {
+        id: 'alarm' | 'bark' | 'growl';
+        seconds: number;
+        animal: number;
+        distance?: number;
+    };
+};
+type HerdEventName = keyof HerdEventMap;
+type HerdNumbers = {
+    readonly range: number;
+    readonly fear: number;
+    readonly walkFactor: number;
+    readonly walkBase: number;
+    readonly runFactor: number;
+    readonly runBase: number;
+    readonly activeDistance: number;
+    readonly companionBehind: number;
+    readonly companionRun: number;
+    readonly companionStop: number;
+    readonly retargetTries: number;
+    readonly restBase: number;
+    readonly restRandom: number;
+    readonly lookEvery: number;
+    readonly lookShare: number;
+    readonly lookRadius: number;
+    readonly fearAgentFactor: number;
+    readonly fearAgentBase: number;
+    readonly fleeStep: number;
+    readonly arrive: number;
+    readonly bodyHeight: number;
+    readonly turn: number;
+    readonly freeHeight: number;
+    readonly worldMargin: number;
+};
+/** The game's numbers (`jogo.js` G 66592-66700 `bichoNovo`, `bichoLivre`, `bichosUpdate`). */
+declare const HERD_DEFAULTS: HerdNumbers;
+/**
+ * The roles of the animals of the deliveries, by `game-animals-species` id: what `bichosPovoar` gives each one (`jogo.js` G 66607-66623) and the
+ * calls of `bichosUpdate` (hen 30 m every 6 s; lapwing 12 m, 40 m, flies 4 s; cow 80 m, 2% a second, every 30 s; dog barks under 12 m, 60 m, every
+ * 3 s, growls under 40 m every 10 s). A game passes its own or changes one.
+ */
+declare const HERD_ROLES: Readonly<Record<string, HerdRole & {
+    readonly sky?: boolean;
+}>>;
+type HerdOptions = {
+    /** Where the camera is: animals farther than 70 m rest, and sounds carry their distance from here. Default: the target. */
+    readonly view?: () => {
+        readonly x: number;
+        readonly z: number;
+    };
+    /** A spot an animal must not wander into (inside a building). */
+    readonly blocked?: (x: number, z: number) => boolean;
+    readonly numbers?: Partial<HerdNumbers>;
+};
+type Herd = {
+    readonly list: readonly HerdAnimal[];
+    /** Adds an animal (draws its heading and its first rest, as the game does). */
+    add(spec: HerdAnimalSpec): HerdAnimal;
+    /** A free spot `r0` to `r1` m from (x, z), or null (G 66601 `bichoLivre`). */
+    free(x: number, z: number, r0: number, r1: number, tries?: number): [number, number] | null;
+    /** Wander, flee, follow, call (G 66648 `bichosUpdate`, without the drawing). */
+    update(dt: number): void;
+    /** The time the herd has run (the flock reads it). */
+    readonly time: number;
+    setCompanion(index: number, on: boolean): void;
+    on<K extends HerdEventName>(event: K, listener: (event: HerdEventMap[K]) => void): () => void;
+};
+/**
+ * Animals on a crowd: a literal port of the team game's animals (`jogo.js` G 66592-66700). Each wanders around home and rests 4 to 11 s, flees
+ * from the target and from the crowd's agents, and may call, raise an alarm or guard the target as its companion. The calls are noises the crowd
+ * hears. The drawing and the bones are the game's (`game-animals-three`).
+ */
+declare function createHerd(crowd: Crowd, options?: HerdOptions): Herd;
+
+/** One bird of a flock this frame: where it is, its heading and its roll, its wing phase, and whether it is close enough to draw. */
+type FlockBird = {
+    x: number;
+    y: number;
+    z: number;
+    yaw: number;
+    roll: number;
+    wing: number;
+    visible: boolean;
+};
+type FlockMode = 
+/** The vultures (G 66700-66708): circle the centre of the bodies on the ground, each at its own speed, radius and height. */
+'carrion'
+/** The birds of the live map (Bancada de Hordas G 53609-53615): a loose ring that rises and falls. */
+ | 'orbit';
+type FlockOptions = {
+    readonly count: number;
+    readonly mode: FlockMode;
+    /** Visible within this distance of the view (carrion 260 m; orbit always). */
+    readonly visibleWithin?: number;
+};
+type Flock = {
+    readonly birds: readonly FlockBird[];
+    /** Moves the flock to time `t` (seconds) around `center`; `view` decides what is visible. */
+    update(t: number, dt: number, center: readonly [number, number], view?: readonly [number, number]): void;
+};
+/** The centre the vultures circle: the mean of the bodies on the ground when there are three or more, else `fallback` (a carcass). */
+declare const carrionCenter: (corpses: readonly {
+    readonly x: number;
+    readonly z: number;
+}[], fallback: readonly [number, number] | null) => [number, number];
+/** A flock of birds by formula: the game's vultures or the live map's ring (literal formulas from the deliveries). */
+declare function createFlock(options: FlockOptions): Flock;
+
+/** What the crowd needs of a region model: `game-infection`'s `Infection` is one as it is. */
+type InfectionModelLike = {
+    materialize(region: string, n: number): {
+        state: 'active' | 'contained' | 'removed';
+        seed: number;
+    }[];
+    giveBack(region: string, batch: {
+        state: 'active' | 'contained' | 'removed';
+        seed: number;
+    }[]): void;
+    infect(region: string, n?: number, hoursElapsed?: number): void;
+};
+type InfectionBindingOptions = {
+    /** Where the k-th agent of a batch is born in the region, from its seed; null skips it (it goes straight back). */
+    readonly place: (region: string, seed: number, k: number) => readonly [number, number] | null;
+    /** The crowd type of an agent (default: drawn by the pack's weights). */
+    readonly typeFor?: (agent: {
+        readonly state: 'active' | 'contained' | 'removed';
+        readonly seed: number;
+    }, region: string) => number;
+    /** The relevance band from which an agent goes back to the model (default 3: farther than 400 m). */
+    readonly giveBackBand?: number;
+    /** Civilians whose bites the model hears about (`infect`), in the region `regionOf` gives. */
+    readonly civilians?: Civilians;
+    readonly regionOf?: (x: number, z: number) => string | null;
+};
+type InfectionBinding = {
+    /** Brings up to `n` infected of `region` out of the model into the crowd. Returns the agents born. */
+    materialize(region: string, n: number): number[];
+    /** Gives back to the model the agents of `region` (all regions when left out) that are in the far band, or all of them with `all`. */
+    giveBack(region?: string, options?: {
+        readonly all?: boolean;
+    }): number;
+    /** The region of a materialised agent, or null. */
+    regionOf(agent: number): string | null;
+    unbind(): void;
+};
+/**
+ * Ties a crowd to a region model (`game-infection`): `materialize` turns the model's numbers into agents near the player, a kill of one of them
+ * goes back to its region as removed, the far ones go back with `giveBack`, and a civilian's bite is an `infect`. No team code exists for this bridge
+ * (decision P12 of the spec); the model's own API is used as it is.
+ */
+declare function bindInfection(crowd: Crowd, model: InfectionModelLike, options: InfectionBindingOptions): InfectionBinding;
+
+export { AGENT_FIELDS, CELL, CIVILIAN_DEFAULTS, CROWD_DEFAULTS, type Civilian, type CivilianBuilding, type CivilianEventMap, type CivilianEventName, type CivilianNumbers, type CivilianOptions, type CivilianSpec, type CivilianState, type Civilians, type Corpse, type Crowd, type CrowdAge, type CrowdBand, type CrowdCaliber, type CrowdDamageResult, type CrowdEffectId, type CrowdEventMap, type CrowdEventName, type CrowdHit, type CrowdMessageId, type CrowdNumbers, type CrowdOptions, type CrowdOutfit, type CrowdPack, type CrowdPlugin, type CrowdSoundId, type CrowdStore, type CrowdTarget, type CrowdTraits, type CrowdType, type CrowdUpdateContext, type CrowdView, DOOR_DEFAULTS, type Door, type DoorEventMap, type DoorEventName, type DoorNumbers, type Doors, type Flock, type FlockBird, type FlockMode, type FlockOptions, HERD_DEFAULTS, HERD_ROLES, type Herd, type HerdAnimal, type HerdAnimalSpec, type HerdEventMap, type HerdEventName, type HerdNumbers, type HerdOptions, type HerdRole, type InfectionBinding, type InfectionBindingOptions, type InfectionModelLike, MISSING, type MigrationOptions, type NavGrid, type NavGridOptions, type PlayerCrowdLike, type Region, STATE, bindInfection, carrionCenter, createCivilians, createCrowd, createDoors, createFlock, createHerd, createNavGrid, createRng, createStore };