@adatechnology/game-characters 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1103 @@
+import { Vec3, SegmentKind, BodyRegion, BodySlot, Hit, Quat, DestructibleSpec, ObjectState, DestructibleImpl, DestructionEvent } from '@adatechnology/game-contracts';
+
+/** The 17 joints of a body: one per segment, the point the segment hangs from. */
+type JointId = 'hip' | 'spine' | 'neck' | 'head' | 'jaw' | 'shoulderL' | 'shoulderR' | 'elbowL' | 'elbowR' | 'wristL' | 'wristR' | 'hipL' | 'hipR' | 'kneeL' | 'kneeR' | 'ankleL' | 'ankleR';
+declare const JOINT_IDS: readonly JointId[];
+/**
+ * Proportions of a body: joint positions in metres for a body of `heightMetres`, standing, feet on y = 0, facing +z, left side on +x.
+ * `segmentRadius` is the radius of the capsule a segment is hit through.
+ */
+type BodySpec = {
+    readonly id: string;
+    readonly heightMetres: number;
+    readonly joints: Readonly<Record<JointId, Vec3>>;
+    readonly segmentRadius: Readonly<Record<SegmentKind, number>>;
+};
+/** The Elenco style guide body (1.80 m, shoulders 0.61 m at 1.475 m, head about 1/6 of the height): the default. */
+declare const GUIDE: BodySpec;
+/**
+ * The game's crowd body (G 65336 `J`, shoulders ±0.24 m), kept for the goldens of the instanced path. `J` has no spine, head, jaw, wrist or
+ * ankle: spine and head sit on the hip and neck bones (bones 0 and 1 of the game), the wrist and ankle one forearm and one shin below.
+ */
+declare const TEAM_GAME: BodySpec;
+/** A body spec from `base` (default `GUIDE`) with the given fields replaced; `joints` and `segmentRadius` merge key by key. */
+declare const createBodySpec: (patch?: Partial<BodySpec>, base?: BodySpec) => BodySpec;
+
+type SegmentSide = 'L' | 'R';
+type LimbKind = 'upperArm' | 'forearm' | 'hand' | 'thigh' | 'shin' | 'foot';
+type SegmentId = 'pelvis' | 'torso' | 'neck' | 'head' | 'jaw' | `${LimbKind}${SegmentSide}`;
+/** One segment of the tree: the joint it hangs from, its parent, the crowd region it belongs to and the item slots that cover it. */
+type SegmentNode = {
+    readonly id: SegmentId;
+    readonly kind: SegmentKind;
+    readonly side?: SegmentSide;
+    readonly joint: JointId;
+    readonly parent?: SegmentId;
+    readonly region: BodyRegion;
+    readonly slots: readonly BodySlot[];
+};
+/** Numbers of a segment kind (the Arsenal table, A4): hit points, damage multiplier and bleed rate. */
+type SegmentNumbers = {
+    readonly hitPoints: number;
+    readonly multiplier: number;
+    readonly bleed: number;
+};
+/** The 17 segments (11 kinds, limbs on both sides), parents before children. Neck and jaw have no item slot: a helmet does not cover them. */
+declare const SEGMENT_TREE: readonly SegmentNode[];
+declare const SEGMENT_IDS: readonly SegmentId[];
+declare const segmentNode: (id: SegmentId) => SegmentNode;
+declare const isSegmentId: (value: string) => value is SegmentId;
+/** Every segment that hangs below `id` (children, grandchildren...), in tree order: what falls with it when it is severed. */
+declare const segmentsBelow: (id: SegmentId) => SegmentId[];
+/** The Arsenal numbers per segment kind (hit points, `MULT`, `BLEED`). */
+declare const SEGMENT_NUMBERS: Readonly<Record<SegmentKind, SegmentNumbers>>;
+
+type BallisticClass = 'pistol' | 'rifle' | 'buckshot';
+/** A `Hit` plus what a body may also use. A plain `Hit` works: every extra field is optional. */
+type BodyHit = Hit & {
+    /** Damage points the caller already resolved (a game's own table): the points step is skipped. */
+    readonly points?: number;
+    /** snake_case calibre id (`9x19`): looks the calibre up in the kit's calibre table. */
+    readonly caliberId?: string;
+    /** Metres from the shooter (the skull range of a shotgun, the head blown off at close range). */
+    readonly distance?: number;
+    /** Projectiles in the load (a shotgun: 9). */
+    readonly pellets?: number;
+    /** `false`: the caller resolved the part without a surface point, so no wound opens at `point` (default true). */
+    readonly woundAtPoint?: boolean;
+};
+/** A calibre as the body model sees it. Every field is optional; a game's own table (`team-game`) fills them all. */
+type CaliberEntry = {
+    readonly id: string;
+    /** Damage points of a fresh hit (overrides `points = 3.5·E^0.37`). */
+    readonly points?: number;
+    /** Penetration points (the `team-game` model). */
+    readonly penetration?: number;
+    readonly class?: BallisticClass;
+    /** Metres within which a head hit is lethal; 1 means always (the game's `cranio`). */
+    readonly skullRange?: number;
+    readonly pellets?: number;
+    /** Metres of full damage; at twice the range the damage is halved (the `team-game` model). */
+    readonly effectiveRangeMetres?: number;
+};
+/** A protection item on the body (`ItemDef.protection` of `game-items` maps onto it). */
+type ProtectionLayer = {
+    readonly id: string;
+    readonly slots: readonly BodySlot[];
+    /** Against projectiles: `resistance` in penetration units; a stopped projectile does `blunt` of its damage, one that goes through `pass` (default `blunt`). */
+    readonly ballistic?: {
+        readonly resistance: number;
+        readonly blunt: number;
+        readonly pass?: number;
+        readonly consumable?: boolean;
+    };
+    /** Factor on fire damage (a turnout coat: 0.25). */
+    readonly fire?: number;
+    /** Factor on arm and leg damage (a turnout coat: 0.8). */
+    readonly limbs?: number;
+    /** 0..1 against a bite and a scratch (the layered T3 formula). */
+    readonly bite?: number;
+    readonly scratch?: number;
+};
+/** What a projectile is, for the protection and the skull: the force P of the `physical` model, the class and range of a calibre table. */
+type ProjectileInfo = {
+    readonly force: number;
+    readonly class: BallisticClass;
+    readonly skullRange: number;
+    readonly pellets: number;
+    readonly distance: number;
+};
+/** How hard a projectile pushes and what stops it. `physical` (P = √(E·m/A)) is the default; `team-game` replays the game's points. */
+type PenetrationModel = {
+    readonly id: string;
+    /** A protection layer stops the projectile (the projectile then does the layer's `blunt` share). */
+    stops(layer: ProtectionLayer, projectile: ProjectileInfo): boolean;
+    /** A head hit is lethal when the skull is pierced and the points reach the head-kill threshold. */
+    piercesSkull(projectile: ProjectileInfo, headResistance: number): boolean;
+};
+/** Numbers of the segment pipeline (the defaults are the design's, from the game, the Elenco and the Arsenal). */
+type SeverityRules = {
+    readonly severAtCut: number;
+    readonly severAtDamageFraction: number;
+    readonly destroyAtDamageMultiple: number;
+    readonly limpAtHpFraction: number;
+    readonly splitAtDamage: number;
+    readonly headKillDamage: number;
+    readonly jawChance: number;
+    readonly jawDamage: number;
+    readonly headBitDamage: number;
+    readonly headBitShotgunMetres: number;
+    readonly stunAtPoints: number;
+    /** Share of a limb hit that also comes off vitality (Arsenal 0.3, game 0.5 for the crowd regions). */
+    readonly limbVitalityShare: number;
+    readonly regionLimbVitalityShare: number;
+};
+type BlastRules = {
+    /** Least points a segment must take from a blast to be hit at all. */
+    readonly minimumPoints: number;
+    /** A blast this strong on the head blows it off. */
+    readonly headDestroyPoints: number;
+    /** A blast this strong on a segment destroys it when it reaches 0. */
+    readonly bigPoints: number;
+};
+type DeathRule = 'vitality-or-head' | 'head-only';
+type SegmentRuleId = 'kit' | 'arsenal' | 'elenco';
+type DamageRules = {
+    readonly deathRule: DeathRule;
+    /** The segment rule: `kit` (default), or a team page replayed exactly (`arsenal`, `elenco`). */
+    readonly segmentRule: SegmentRuleId;
+    readonly severity: SeverityRules;
+    readonly blast: BlastRules;
+    /** Default `cut` by damage type and projectile class. */
+    readonly defaultCut: {
+        readonly slash: number;
+        readonly blunt: number;
+        readonly explosive: number;
+        readonly ballistic: Readonly<Record<BallisticClass, number>>;
+    };
+    /** `points = coefficient · E^exponent` (E in joules). */
+    readonly points: {
+        readonly coefficient: number;
+        readonly exponent: number;
+    };
+    /** Random spread of the points of a blow: ±spread (the Elenco: 0.15). 0 = no draw. */
+    readonly spread: number;
+    /** Per segment kind: hit points, damage multiplier and bleed rate. */
+    readonly segments: Readonly<Record<SegmentKind, {
+        readonly hitPoints: number;
+        readonly multiplier: number;
+        readonly bleed: number;
+    }>>;
+    /** Fire on a body: points per second of exposure. */
+    readonly burnPointsPerSecond: number;
+};
+/** What the last hit did, for a HUD (hit marker, headshot) and for tests. */
+type HitReport = {
+    readonly part?: string;
+    readonly points: number;
+    readonly killed: boolean;
+    readonly headshot: boolean;
+    /** The projectile went through (the `physical` model): `exitEnergy` is what is left of it. */
+    readonly through: boolean;
+    readonly exitEnergy: number;
+    /** A protection layer absorbed the hit completely (a helmet). */
+    readonly absorbedBy?: string;
+};
+
+/** The kit's rules: Arsenal numbers per segment (A4), the design's severity, the game's head rule, death by vitality or head. */
+declare const DEFAULT_DAMAGE_RULES: DamageRules;
+/** The Galeria 3D do Arsenal, replayed: its `damage`, `sever`, `explodeSeg`, `splitTorso`, `legLost` and `grenadeAt`. */
+declare const ARSENAL_RULES: DamageRules;
+/** The Elenco, replayed: its own hit points, no multiplier, ±15 % per blow and its cut rule (`hit`, `sever`, `breakBone`); a torso at 0 kills (a human). */
+declare const ELENCO_RULES: DamageRules;
+declare const DAMAGE_PRESETS: {
+    readonly kit: DamageRules;
+    readonly arsenal: DamageRules;
+    readonly elenco: DamageRules;
+};
+/** The protection presets that reproduce the game's `ROUPAS` (tools/characters-catalog/decisions.json `protectionPresets`). */
+declare const PROTECTION_PRESETS: readonly ProtectionLayer[];
+/** The game's calibre table (`CALIBRES`) under the kit's calibre ids, for the `team-game` model. */
+declare const TEAM_GAME_CALIBERS: readonly CaliberEntry[];
+/** The game's calibre keys (`9x19`, `12ga`, `762x39`, `308`) to the kit's calibre ids. */
+declare const TEAM_GAME_CALIBER_KEYS: Readonly<Record<string, string>>;
+
+type AgeGroup = 'child' | 'young' | 'adult' | 'elder';
+/** `segments`: the 17 segments (near, rich path); `regions`: the 6 crowd regions of the game (far, instanced path). */
+type Detail = 'segments' | 'regions';
+/** `ok` untouched, `wounded` hit, `broken` bone broken (still attached), `severed` cut off at its joint, `destroyed` blown to pieces. */
+type SegmentStatus = 'ok' | 'wounded' | 'broken' | 'severed' | 'destroyed';
+type SegmentState = {
+    readonly id: SegmentId;
+    readonly kind: SegmentKind;
+    readonly side?: SegmentSide;
+    readonly region: BodyRegion;
+    hp: number;
+    readonly max: number;
+    status: SegmentStatus;
+    /** Still on the body (false once it or a segment above it is severed or destroyed). */
+    attached: boolean;
+};
+/** Damage multipliers of a body type per body part (a zombie type's `mult`); 1 by default. */
+type BodyMultipliers = {
+    readonly head: number;
+    readonly torso: number;
+    readonly arms: number;
+    readonly legs: number;
+};
+/** What makes one character. Everything but `seed` and `kind` is optional; a preset (`kind`, or `preset`) fills what the spec leaves out. */
+type CharacterSpec = {
+    readonly seed: number;
+    /** `person`, or a preset id (a profession, an undead type...). */
+    readonly kind: string;
+    readonly id?: string;
+    /** Preset to start from (default: the preset whose id is `kind`, when there is one). */
+    readonly preset?: string;
+    readonly sex?: 'male' | 'female';
+    readonly age?: AgeGroup;
+    /** Height in metres (default the body spec's). */
+    readonly height?: number;
+    /** Width factor (default 1). */
+    readonly build?: number;
+    /** Outfit id (content packs define them). */
+    readonly outfit?: string;
+    /** Ids of the protection layers worn (`vest_police`, `helmet_combat`...). */
+    readonly protection?: readonly string[];
+    /** Free data for content packs (an undead type, a profession...). The engine never reads it. */
+    readonly traits?: Readonly<Record<string, unknown>>;
+    /** Starting vitality (default 100). */
+    readonly vitality?: number;
+    readonly multipliers?: Partial<BodyMultipliers>;
+    /** Extra damage taken by arms and legs (the age of a zombie: `membro`); default 1. */
+    readonly limbFactor?: number;
+    /** Scales every bleed rate (the age of a zombie: `sangue`); default 1. */
+    readonly bloodFactor?: number;
+    /** How many bodies the torso counts as for penetration (a brute: 2); default 1. */
+    readonly bodyCount?: number;
+    /** Seconds a heavy hit stuns (default 0.45). */
+    readonly stunSeconds?: number;
+    readonly detail?: Detail;
+    /** Starts crawling (a crawler). */
+    readonly crawling?: boolean;
+    /**
+     * A random stream to draw from instead of the per-hit stream (`seed ^ hit counter`). For replaying a recorded game: the goldens pass the
+     * team's own stream here.
+     */
+    readonly random?: () => number;
+};
+/** A named starting point for specs (a profession, a force, an undead type). */
+type CharacterPreset = {
+    readonly id: string;
+} & Partial<Omit<CharacterSpec, 'seed' | 'id' | 'preset' | 'random'>>;
+/** Content added by a pack (people, uniformed, undead...). */
+type CharacterPack = {
+    readonly id: string;
+    readonly presets?: readonly CharacterPreset[];
+    /** Protection layers by id (vests, helmets, coats). */
+    readonly protection?: readonly ProtectionLayer[];
+    /** Calibre entries by id (a game's own points table). */
+    readonly calibers?: readonly CaliberEntry[];
+};
+/** Damage rules: a preset (`kit` by default, or a team page replayed: `arsenal`, `elenco`) with fields replaced. */
+type DamageOptions = Partial<Omit<DamageRules, 'severity' | 'blast' | 'segments'>> & {
+    readonly preset?: keyof typeof DAMAGE_PRESETS;
+    readonly severity?: Partial<SeverityRules>;
+    readonly blast?: Partial<BlastRules>;
+    readonly segments?: Partial<DamageRules['segments']>;
+};
+type CorpseOptions = {
+    readonly max: number;
+    readonly seconds: number;
+};
+type CharactersOptions = {
+    readonly packs?: readonly CharacterPack[];
+    /** Fields to change in presets, by id. */
+    readonly patch?: Readonly<Record<string, Partial<CharacterPreset>>>;
+    /** Preset ids to remove. */
+    readonly remove?: readonly string[];
+    /** Proportions (default `GUIDE`); `joints` and `segmentRadius` merge key by key. */
+    readonly body?: Partial<BodySpec>;
+    /** Corpse cap and lifetime (default 400 bodies, 900 s). */
+    readonly corpses?: Partial<CorpseOptions>;
+    readonly damage?: DamageOptions;
+    /** `physical` (P = √(E·m/A), default), `team-game` (the game's points; for the goldens) or a model of your own. */
+    readonly penetration?: PenetrationModel | 'physical' | 'team-game';
+    /** Protection layers added to (or replacing, by id) the presets `vest_police`, `vest_military`, `helmet_combat`, `turnout_gear`. */
+    readonly protection?: readonly ProtectionLayer[];
+    /** Calibre entries (points, class, skull range...) by calibre id. */
+    readonly calibers?: readonly CaliberEntry[];
+};
+
+type CorpseEntry<TData> = {
+    /** Seconds since it fell. */
+    age: number;
+    readonly data: TData;
+};
+type CorpseLedger<TData> = {
+    readonly entries: readonly CorpseEntry<TData>[];
+    readonly count: number;
+    /** Adds a corpse; when the ledger is full the oldest one is replaced. Returns the replaced data, if any. */
+    add(data: TData): TData | undefined;
+    /** Ages every corpse by `dt` seconds and removes the ones past their life (swap with the last, like the game). Returns the removed data. */
+    update(dt: number): TData[];
+    clear(): void;
+};
+/** The bodies left on the ground: capped (400) and gone after a lifetime (900 s); generic over what each one carries. */
+declare const createCorpseLedger: <TData>(options: CorpseOptions) => CorpseLedger<TData>;
+
+/** The regions that keep their own hit points in the crowd model (the torso has none: torso hits go to vitality). */
+type LimbRegion = Exclude<BodyRegion, 'torso'>;
+declare const LIMB_REGIONS: readonly LimbRegion[];
+/** The game's region numbers (`SEG`): hit points of the head, of an arm and of a leg. */
+declare const REGION_HIT_POINTS: Readonly<Record<LimbRegion, number>>;
+/** The segments that make up each region, and the one that names it in events (the first). */
+declare const REGION_SEGMENTS: Readonly<Record<BodyRegion, readonly SegmentId[]>>;
+declare const BODY_REGIONS: readonly BodyRegion[];
+declare const isBodyRegion: (value: string) => value is BodyRegion;
+
+/** The bones of the game's instanced body (G 65336): 0 torso and hip, 1 head, 2/3 arms, 4/5 thighs, 6 eyes, 7/8 forearms, 9/10 shins, 11 jaw. */
+declare const GAME_BONES: {
+    readonly torso: 0;
+    readonly head: 1;
+    readonly upperArmL: 2;
+    readonly upperArmR: 3;
+    readonly thighL: 4;
+    readonly thighR: 5;
+    readonly eyes: 6;
+    readonly forearmL: 7;
+    readonly forearmR: 8;
+    readonly shinL: 9;
+    readonly shinR: 10;
+    readonly jaw: 11;
+};
+declare const JOINT_PARENTS: Readonly<Record<JointId, JointId | undefined>>;
+/** The joints of one body, scaled to its height and build. */
+type Rig = {
+    readonly joints: Readonly<Record<JointId, Vec3>>;
+    readonly parents: Readonly<Record<JointId, JointId | undefined>>;
+    readonly gameBones: typeof GAME_BONES;
+    /** Height in metres of this body. */
+    readonly height: number;
+};
+type CreateRigParams = {
+    readonly body: BodySpec;
+    readonly height: number;
+    readonly build: number;
+};
+/** Joints of `body` scaled to `height` metres (vertical and depth) and to `build` (width). */
+declare const createRig: ({ body, height, build }: CreateRigParams) => Rig;
+
+/** A spec with every default filled in. */
+type ResolvedCharacterSpec = CharacterSpec & {
+    readonly id: string;
+    readonly height: number;
+    readonly build: number;
+    readonly vitality: number;
+    readonly multipliers: BodyMultipliers;
+    readonly limbFactor: number;
+    readonly bloodFactor: number;
+    readonly bodyCount: number;
+    readonly stunSeconds: number;
+    readonly protection: readonly string[];
+    readonly detail: Detail;
+};
+type Character = {
+    readonly id: string;
+    readonly spec: ResolvedCharacterSpec;
+    readonly rig: Rig;
+    /** Live view of the 17 segments. */
+    readonly segments: readonly SegmentState[];
+    readonly detail: Detail;
+    /** Hit points of the 5 crowd regions (head, arms, legs). */
+    regionHitPoints(): Readonly<Record<LimbRegion, number>>;
+    /** Swaps the detail level: segments to regions sums each region (lossless); regions to segments spreads the region's share (lossy). */
+    setDetail(detail: Detail): void;
+    setTransform(position: Vec3, rotation?: Quat): void;
+    describe(): DestructibleSpec;
+    state(): ObjectState;
+    reset(): void;
+};
+
+/** A bleeding wound: `rate` in drops per second (the Arsenal's unit) fading to 0 over `duration` seconds; `spurt` pulses like an artery. */
+type Bleeder = {
+    readonly part: SegmentId;
+    readonly rate: number;
+    readonly duration: number;
+    readonly spurt: boolean;
+    age: number;
+    /** Whole seconds of this bleeder already reported as `leak` events. */
+    reported: number;
+};
+/** Volume of one drop (a 4 mm drop of the Arsenal's blood): `leak` events carry litres per second. */
+declare const BLOOD_LITERS_PER_DROP = 0.00027;
+declare const bleedRateAt: (bleeder: Bleeder) => number;
+
+/** A character with the damage model: a `DestructibleImpl` a destruction world can host next to its own objects. */
+type DamageCharacter = Character & DestructibleImpl & {
+    readonly alive: boolean;
+    /** The sides that limp, in the order they started. */
+    readonly limping: readonly SegmentSide[];
+    /** Seconds of stagger left from a heavy hit. */
+    readonly stunSeconds: number;
+    /** What the last `hit` did (points, kill, headshot, through). */
+    readonly lastHit?: HitReport;
+    /** The bleeding wounds, oldest first. */
+    bleeders(): readonly Readonly<Bleeder>[];
+    /** 0..1 protection of the layers over a segment against a bite or a scratch (the layered T3 formula, capped at 90 %). */
+    protectionAgainst(attack: 'bite' | 'scratch', part: SegmentId): number;
+    /** Ids of the protection layers worn and not used up (a helmet that took its shot is gone). */
+    intactProtection(): readonly string[];
+    /** Penetration resistance R of the path through a part (a segment or a region id), with the protection worn over it. */
+    resistanceOf(part: string): number;
+    hit(hit: Hit | BodyHit): DestructionEvent[];
+    /** Ages bleeders (a `leak` per second each) and the stun. */
+    update(dt: number): DestructionEvent[];
+    serialize(): unknown;
+    load(data: unknown): void;
+};
+
+/** One body in the line of fire, `distance` metres from the muzzle. */
+type LineTarget = {
+    readonly character: DamageCharacter;
+    readonly part: string;
+    readonly distance: number;
+    readonly point?: Vec3;
+};
+/** What the line needs from a shot (a `Shot` of game-weapons fits). */
+type LineShot = {
+    readonly energyAt: (distance: number) => number;
+    /** Projectile grams. */
+    readonly mass: number;
+    /** Diameter in mm. */
+    readonly caliber: number;
+    readonly caliberId?: string;
+    readonly source?: string;
+};
+type LineHit = {
+    readonly index: number;
+    readonly points: number;
+    readonly energy: number;
+    readonly killed: boolean;
+    readonly headshot: boolean;
+    readonly events: DestructionEvent[];
+};
+type LineResult = {
+    readonly hits: LineHit[]; /** 1-based index of the last body hit (0: none). */
+    readonly stoppedAt: number;
+};
+type PenetrateLineParams = {
+    readonly model: 'physical' | 'team-game';
+    readonly shot: LineShot;
+    readonly targets: readonly LineTarget[];
+    readonly calibers: ReadonlyMap<string, CaliberEntry>;
+};
+/** A shot through a line of bodies, nearest first. Each body takes the hit through its own damage model. */
+declare const penetrateLine: (params: PenetrateLineParams) => LineResult;
+
+declare const DEFAULT_CORPSES: CorpseOptions;
+/** The base preset every spec can start from: an unnamed adult person. */
+declare const PERSON_PRESET: CharacterPreset;
+type CharacterKit = {
+    readonly body: BodySpec;
+    readonly presets: ReadonlyMap<string, CharacterPreset>;
+    readonly corpses: CorpseOptions;
+    readonly damage: DamageRules;
+    readonly penetration: PenetrationModel;
+    readonly protection: ReadonlyMap<string, ProtectionLayer>;
+    readonly calibers: ReadonlyMap<string, CaliberEntry>;
+    /** A new character: the preset (`spec.preset`, else the one named `spec.kind`) under the spec. */
+    create(spec: CharacterSpec): DamageCharacter;
+    /** The bodies left on the ground, capped and timed by the kit's `corpses` option. */
+    createCorpses<TData>(): CorpseLedger<TData>;
+    /** A shot through a line of bodies with the kit's penetration model and calibre table. */
+    penetrateLine(shot: LineShot, targets: readonly LineTarget[]): LineResult;
+};
+/** Fills a spec from its preset: what the spec says wins; `multipliers` merge field by field. */
+declare const applyPreset: (spec: CharacterSpec, presets: ReadonlyMap<string, CharacterPreset>) => CharacterSpec;
+/** The rules of a preset (`kit` by default) with the given fields replaced; `severity`, `blast` and `segments` merge key by key. */
+declare const resolveDamageRules: (options?: DamageOptions) => DamageRules;
+declare const createCharacters: (options?: CharactersOptions) => CharacterKit;
+
+/** The material id the parts of a body carry (a destruction world without it skips its own material rules: the body is a `DestructibleImpl`). */
+declare const BODY_MATERIAL = "flesh";
+type DescribeBodyParams = {
+    readonly rig: Rig;
+    readonly body: BodySpec;
+    readonly build: number;
+    readonly name?: string;
+};
+/** The body as destruction parts (one per segment, in the body's local space) and the joints between them. */
+declare const describeBody: ({ rig, body, build, name }: DescribeBodyParams) => DestructibleSpec;
+
+type Entry = {
+    readonly id: string;
+};
+/** The shipped entries with the ones from `extra` added or, when the id exists, replaced. */
+declare const mergeById: <TEntry extends Entry>(shipped: readonly TEntry[], extra: readonly TEntry[] | undefined) => Map<string, TEntry>;
+/** Applies `patch` by id (a shallow merge); a patch for an id that does not exist is ignored. */
+declare const applyPatches: <TEntry extends Entry>(entries: Map<string, TEntry>, patches: Readonly<Record<string, Partial<TEntry>>> | undefined) => void;
+declare const removeIds: (entries: Map<string, unknown>, ids: readonly string[] | undefined) => void;
+
+/** Cycles per second at `speed` m/s (the game's `walkCad`). */
+declare const walkCadence: (speed: number) => number;
+/** Hip swing in radians at `speed` m/s for a body `height` times the base height: the stride that makes the foot meet the ground (the game's `walkGait`). */
+declare const walkGait: (speed: number, height?: number) => number;
+type StrideParams = {
+    readonly speed: number;
+    readonly height?: number;
+    /** Default true: cadence and swing come from the speed, so the feet do not slide. False keeps the profile's own numbers (the Bestiário preset). */
+    readonly strideFromSpeed?: boolean;
+};
+type Stride = {
+    /** Cycles per second. */
+    readonly frequency: number;
+    /** Thigh swing, radians. */
+    readonly swing: number;
+    /** Knee bend, radians. */
+    readonly kneeBend: number;
+};
+/** The gait numbers for a speed: from the ground-matching stride, or `fallback` (the profile) when `strideFromSpeed` is false. */
+declare const strideFor: ({ speed, height, strideFromSpeed }: StrideParams, fallback: Stride) => Stride;
+
+var cascade = {
+	hip: 16,
+	spine: 11,
+	shoulder: 9,
+	elbow: 7,
+	leg: 14,
+	knee: 11,
+	head: 6
+};
+var 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
+	}
+};
+var gait = {
+	cascade: cascade,
+	moves: moves};
+
+/** How a body type walks: offsets over its rest pose (the Bestiário's `GAIT`). `f` cycles per second, `a` thigh swing, `k` knee bend, `arm` arm swing. */
+type GaitProfile = {
+    readonly f: number;
+    readonly a?: number;
+    readonly k?: number;
+    readonly arm?: number;
+    readonly bob?: number;
+    readonly sway?: number;
+    readonly drag?: boolean;
+    readonly crawl?: boolean;
+    readonly idle?: boolean;
+    readonly eat?: boolean;
+    readonly leap?: boolean;
+    readonly listen?: boolean;
+    readonly stalk?: boolean;
+    readonly sniff?: boolean;
+};
+type JointAngles = {
+    readonly shoulder: number;
+    readonly elbow: number;
+};
+type LegAngles = {
+    readonly hip: number;
+    readonly knee: number;
+    readonly lost?: boolean;
+};
+/**
+ * The pose the gait swings around. `arms[0]` is the right arm and `arms[1]` the left; `legs[0]` is the left leg and `legs[1]` the right
+ * (the order the Bestiário builds them in). `hipY` is the rest height of the hips.
+ */
+type RestPose = {
+    readonly hipY: number;
+    readonly lean: number;
+    readonly headX: number;
+    readonly arms: readonly [JointAngles, JointAngles];
+    readonly legs: readonly [LegAngles, LegAngles];
+};
+/** What a gait sets this frame; a field the gait does not write stays `undefined` and the joint keeps what it had. */
+type GaitSample = {
+    hipY?: number;
+    upper: {
+        x?: number;
+        y?: number;
+        z?: number;
+    };
+    head: {
+        x?: number;
+        y?: number;
+    };
+    arms: {
+        shoulder?: number;
+        elbow?: number;
+    }[];
+    legs: {
+        hip?: number;
+        knee?: number;
+    }[];
+};
+declare const emptySample: () => GaitSample;
+type CascadeJoint = keyof typeof gait.cascade;
+/** Cascade rates per joint (1/s): each joint reaches its target with a delay, from the hips to the head (Bestiário 12.3). */
+declare const CASCADE: Readonly<Record<CascadeJoint, number>>;
+/** The 8 poses of the instanced body, in the order of the game's `iB.w`. */
+declare const INSTANCE_POSES: readonly ["walk", "crawl", "fallen", "attack", "scream", "crouch", "leap", "eat"];
+type InstancePose = (typeof INSTANCE_POSES)[number];
+/** `iB.w` of the instanced body: the pose plus 16 times the ground height in millimetres (a pile of bodies, a jump). */
+declare const encodePoseHeight: (pose: InstancePose, height?: number) => number;
+declare const decodePoseHeight: (encoded: number) => {
+    readonly pose: InstancePose;
+    readonly height: number;
+};
+
+type AnimateProfileParams = {
+    readonly profile?: GaitProfile;
+    readonly rest: RestPose;
+    /** Seconds. */
+    readonly time: number;
+    /** Per-body phase offset, radians (the page's `rig.ph`). */
+    readonly phase: number;
+    /** With `strideFromSpeed`, the speed and height that set cadence and swing. Without it the profile's own numbers are used. */
+    readonly stride?: StrideParams;
+};
+/** Joint targets of one gait at `time` (the Bestiário's `animate0`), as numbers; the rig applies the ones that are set. */
+declare const animateProfile: ({ profile, rest, time, phase, stride }: AnimateProfileParams) => GaitSample;
+
+/** One joint moving toward its target: it covers `dt · rate` of the distance each step (never more than all of it). */
+declare const stepCascade: (current: number, target: number, dt: number, joint: CascadeJoint, rates?: Readonly<Record<CascadeJoint, number>>) => number;
+/** Between two poses by joint name: a joint `from` does not name starts at the target (the Bestiário's `lerpPose`). */
+declare const lerpPose: <TPose extends Readonly<Record<string, number>>>(from: Partial<TPose>, to: TPose, amount: number) => TPose;
+
+type MoveId = keyof typeof gait.moves;
+type MoveBlend = {
+    gait: number;
+    freq: number;
+    amp: number;
+    knee: number;
+    bob: number;
+    lean: number;
+    arm: number;
+    elb: number;
+    crouch: number;
+    aim: number;
+    turn: number;
+    grip: number;
+};
+/** The human movement states the Elenco blends every frame. */
+declare const MOVES: Readonly<Record<MoveId, Readonly<MoveBlend>>>;
+declare const MOVE_BLEND_RATE = 4;
+declare const moveBlendOf: (move: MoveId) => MoveBlend;
+/** Moves `current` toward the target move: each number covers `dt · 4` of the distance (never past it). Mutates and returns `current`. */
+declare const blendMoves: (current: MoveBlend, target: MoveId | Readonly<MoveBlend>, dt: number) => MoveBlend;
+type HumanArm = {
+    readonly side: 1 | -1;
+    readonly hold?: boolean;
+};
+type HumanPoseParams = {
+    readonly moves: Readonly<MoveBlend>;
+    /** Seconds since the start. */
+    readonly time: number;
+    /** The character's own phase offset. */
+    readonly phase: number;
+    /** `phase + offset`: the walking cycle's angle, advanced by `dt · freq`. */
+    readonly cycle: number;
+    /** The character's resting hunch plus the stage's. */
+    readonly hunch: number;
+    /** The infection stage's arm raise (0 healthy .. 1 reanimated). */
+    readonly armRaise: number;
+    /** Stage index: 3 and up adds a spine tremor, 4 is the reanimated body. */
+    readonly stage: number;
+    /** The `prefers-reduced-motion` mode: no idle motion, no gait. */
+    readonly reduced?: boolean;
+    readonly skirt?: boolean;
+    /** [right, left] as built: side and whether the hand holds an item. */
+    readonly arms: readonly [HumanArm, HumanArm];
+    /** [left, right] leg sides. */
+    readonly legSides: readonly [1 | -1, 1 | -1];
+};
+type HumanPose = {
+    readonly chestScaleY: number;
+    readonly hip: {
+        readonly x: number;
+        readonly y: number;
+        readonly zRotation: number;
+    };
+    readonly upper: {
+        readonly x: number;
+        readonly y: number;
+        readonly z: number;
+    };
+    readonly head: {
+        readonly x: number;
+        readonly y: number;
+        readonly z: number;
+    };
+    readonly legs: readonly {
+        readonly hip: number;
+        readonly knee: number;
+        readonly hipZ: number;
+    }[];
+    readonly arms: readonly {
+        readonly shoulder: number;
+        readonly shoulderZ: number;
+        readonly elbow: number;
+        readonly wrist: number;
+        readonly grip: number;
+    }[];
+};
+/** The blended walk of the Elenco for one frame (hips, spine, head, legs, arms), as joint targets. Pure: the caller keeps the phase and the blend. */
+declare const humanPose: (params: HumanPoseParams) => HumanPose;
+/** A leg that cannot carry weight (limp): the swing shrinks to 30%, the knee straightens, the spine leans toward the good leg. */
+declare const LIMP: {
+    readonly swing: 0.3;
+    readonly knee: 0.05;
+    readonly lean: 0.07;
+};
+
+/** Prone crawl on the arms (the Elenco's leg-less body): joint targets at `time`; `figTilt` is the body's tilt target, which the caller approaches at `dt · 4`. */
+type CrawlPose = {
+    readonly figTilt: number;
+    readonly hipY: number;
+    readonly hipZRotation: number;
+    readonly upper: {
+        readonly x: number;
+        readonly y: number;
+    };
+    readonly headX: number;
+    readonly arms: readonly {
+        readonly shoulder: number;
+        readonly shoulderZ: number;
+        readonly elbow: number;
+    }[];
+    readonly legs: readonly {
+        readonly hip: number;
+        readonly knee: number;
+    }[];
+};
+declare const CRAWL_TILT_RATE = 4;
+declare const DEAD_TILT_RATE = 3;
+declare const crawlPose: (time: number, phase: number, sides: readonly [1 | -1, 1 | -1]) => CrawlPose;
+type DeadPose = {
+    readonly figTilt: number;
+    readonly hipY: number;
+    readonly headY: number;
+    readonly arms: readonly {
+        readonly shoulder: number;
+        readonly shoulderZ: number;
+        readonly elbow: number;
+    }[];
+    readonly legs: readonly {
+        readonly hip: number;
+        readonly hipZ: number;
+        readonly knee: number;
+    }[];
+};
+/** A body on the ground (the Elenco's death pose); the caller approaches `figTilt` at `dt · 3`. */
+declare const deadPose: (armSides: readonly [1 | -1, 1 | -1]) => DeadPose;
+
+type ConditionPhase = {
+    readonly id: string;
+    /** When the phase starts, in the timeline's units (hours, or seconds on an accelerated clock). The first phase starts at 0. */
+    readonly startsAt: number;
+    /** Numbers the phase drives (skin tint, hunch, arm raise, ...), by name. */
+    readonly effects?: Readonly<Record<string, number>>;
+};
+type ConditionOptions = {
+    readonly phases: readonly ConditionPhase[];
+    /** Timeline units per real second: 1 on a clock already in seconds (the accelerated preset), 1/3600 for hours. Default 1. */
+    readonly unitsPerSecond?: number;
+    /** Interpolate effects toward the next phase instead of stepping. Default false. */
+    readonly blend?: boolean;
+};
+type ConditionSample = {
+    readonly index: number;
+    readonly phase: ConditionPhase;
+    /** 0..1 inside the current phase (1 on the last one). */
+    readonly progress: number;
+    readonly effects: Readonly<Record<string, number>>;
+    readonly isFinal: boolean;
+};
+type ConditionTimeline = {
+    readonly elapsed: number;
+    /** Advances the clock by `seconds` of real time. */
+    advance(seconds: number): ConditionSample;
+    /** Jumps the clock to `units` of the timeline. */
+    seek(units: number): ConditionSample;
+    sample(): ConditionSample;
+    reset(): void;
+};
+/** A condition that moves through ordered phases over time (an infection: well, fever, delirium, reanimated). Generic: phases and effects are data. */
+declare const createConditionTimeline: (options: ConditionOptions) => ConditionTimeline;
+
+type BuildClass = 'lean' | 'average' | 'heavy';
+/** What `zSpawn` draws for a body: height, width, how it builds up and the speed jitters. Every field comes from the stream, in the game's order. */
+type BodyVariance = {
+    readonly height: number;
+    readonly build: number;
+    readonly buildClass: BuildClass;
+    /** Multiplies the chase speed: the build factor times a 0.92 .. 1.08 jitter. */
+    readonly speedFactor: number;
+    /** Multiplies the wander speed: 0.8 .. 1.2. */
+    readonly wanderFactor: number;
+    /** Multiplies the health: 0.9 lean, 1.15 heavy. */
+    readonly healthFactor: number;
+};
+type VarianceScale = {
+    readonly height?: number;
+    readonly build?: number;
+};
+/**
+ * One body's variance from `random`, drawing exactly what the game's `zSpawn` draws after the type, age and outfit picks:
+ * three draws for the height (a gaussian), one for the build band plus one inside it, one for the speed and one for the wander speed.
+ * `scale` is the type's own scale (a brute's 1.42) and `build` its width factor.
+ */
+declare const drawBodyVariance: (random: () => number, scale?: VarianceScale) => BodyVariance;
+/** Variants baked per type (the game's `nv`): 4 walkers, 3 runners, 2 crawlers and brutes, 1 for the rest. */
+declare const variantCountFor: (typeId: string) => number;
+/** The seed of variant `variant` of the type at `typeIndex` (the game's ZVAR rule: `7000 + c·101 + v·13`). */
+declare const variantSeed: (typeIndex: number, variant: number) => number;
+/** The decay each variant is baked at: 1, 2, 1, 2. */
+declare const variantDecay: (variant: number) => number;
+
+/** The colour and style pools of the Bestiário v17 builder, in the order its random stream picks from them. */
+declare const SKIN_TONES: readonly [15845797, 14724224, 13012066, 11039050, 9067066, 6175526];
+declare const TOP_COLORS: readonly [4878230, 9321275, 6113850, 5208643, 7040888, 4153146, 5917294, 9071162, 12104354, 2894896, 10111530, 3104099, 13216074, 8007242, 14210248, 3820138];
+declare const PANTS_COLORS: readonly [2896704, 2040360, 4866096, 5922662, 3820138, 6969920, 2767402];
+declare const SLEEVES: readonly ["short", "short", "long", "tank"];
+declare const HAIR_STYLES_FEMALE: readonly ["long", "long", "bun", "short", "afro", "bald"];
+declare const HAIR_STYLES_MALE: readonly ["short", "short", "buzz", "bald", "afro", "long"];
+declare const CAP_COLORS: readonly [9321275, 2894896, 3820138, 13216074];
+declare const BAG_COLORS: readonly [3820090, 5909028, 2896704];
+declare const HAIR_COLORS: readonly [1709072, 2760214, 3877920, 6965802, 11569744, 8006170];
+declare const SHOE_COLORS: readonly [1908514, 3811866, 12104872, 4856346];
+/** Uniform bodies (the crowd's baked variants): skin by decay, shirt by type index. */
+declare const DECAY_SKIN: readonly [13482920, 9740420, 8090698, 9206878];
+declare const UNIFORM_SHIRTS: readonly [4878230, 9321275, 6113850, 5208643, 7040888, 4153146, 5917294, 9071162];
+declare const UNIFORM_PANTS = 2896704;
+declare const UNIFORM_SHOES = 1908514;
+declare const SKIN_DECAY_BLEND: readonly [0.45, 0.65, 0.8, 0.88];
+declare const GRAY = 4868678;
+declare const RED = 8000012;
+declare const BLOOD_COLORS: readonly [10361618, 7214096, 4860440, 1840658];
+declare const OLD_HAIR = 9078656;
+
+declare const palette_BAG_COLORS: typeof BAG_COLORS;
+declare const palette_BLOOD_COLORS: typeof BLOOD_COLORS;
+declare const palette_CAP_COLORS: typeof CAP_COLORS;
+declare const palette_DECAY_SKIN: typeof DECAY_SKIN;
+declare const palette_GRAY: typeof GRAY;
+declare const palette_HAIR_COLORS: typeof HAIR_COLORS;
+declare const palette_HAIR_STYLES_FEMALE: typeof HAIR_STYLES_FEMALE;
+declare const palette_HAIR_STYLES_MALE: typeof HAIR_STYLES_MALE;
+declare const palette_OLD_HAIR: typeof OLD_HAIR;
+declare const palette_PANTS_COLORS: typeof PANTS_COLORS;
+declare const palette_RED: typeof RED;
+declare const palette_SHOE_COLORS: typeof SHOE_COLORS;
+declare const palette_SKIN_DECAY_BLEND: typeof SKIN_DECAY_BLEND;
+declare const palette_SKIN_TONES: typeof SKIN_TONES;
+declare const palette_SLEEVES: typeof SLEEVES;
+declare const palette_TOP_COLORS: typeof TOP_COLORS;
+declare const palette_UNIFORM_PANTS: typeof UNIFORM_PANTS;
+declare const palette_UNIFORM_SHIRTS: typeof UNIFORM_SHIRTS;
+declare const palette_UNIFORM_SHOES: typeof UNIFORM_SHOES;
+declare namespace palette {
+  export { palette_BAG_COLORS as BAG_COLORS, palette_BLOOD_COLORS as BLOOD_COLORS, palette_CAP_COLORS as CAP_COLORS, palette_DECAY_SKIN as DECAY_SKIN, palette_GRAY as GRAY, palette_HAIR_COLORS as HAIR_COLORS, palette_HAIR_STYLES_FEMALE as HAIR_STYLES_FEMALE, palette_HAIR_STYLES_MALE as HAIR_STYLES_MALE, palette_OLD_HAIR as OLD_HAIR, palette_PANTS_COLORS as PANTS_COLORS, palette_RED as RED, palette_SHOE_COLORS as SHOE_COLORS, palette_SKIN_DECAY_BLEND as SKIN_DECAY_BLEND, palette_SKIN_TONES as SKIN_TONES, palette_SLEEVES as SLEEVES, palette_TOP_COLORS as TOP_COLORS, palette_UNIFORM_PANTS as UNIFORM_PANTS, palette_UNIFORM_SHIRTS as UNIFORM_SHIRTS, palette_UNIFORM_SHOES as UNIFORM_SHOES };
+}
+
+type HairStyle = (typeof HAIR_STYLES_FEMALE)[number] | (typeof HAIR_STYLES_MALE)[number];
+type OutfitLook = {
+    readonly cloth?: number;
+    readonly pants?: number;
+    readonly hat?: string;
+};
+type AppearanceParams = {
+    readonly seed: number;
+    /** The look of an outfit (police, military ...): its colours replace the draws, so the stream does not spend them. */
+    readonly outfit?: OutfitLook;
+    /** A baked crowd variant: no random look, fixed skin, shirt by `typeIndex`, short hair. */
+    readonly uniform?: boolean;
+    readonly typeIndex?: number;
+    readonly clothIndex?: number;
+    /** Forces the sex; unset draws it (42% female). */
+    readonly female?: boolean;
+    /** False for bodies that are never female (a brute): the draw is skipped. */
+    readonly allowFemale?: boolean;
+    readonly tone?: number;
+    readonly hairStyle?: HairStyle;
+    readonly hairColor?: number;
+    /** The type's own look: wet bodies have long hair, charred ones are bald. */
+    readonly wet?: boolean;
+    readonly charred?: boolean;
+    /** A living person: no bag, no tear. */
+    readonly human?: boolean;
+    /** 0 fresh-dead, 1 normal, 2 old (grey hair). */
+    readonly life?: number;
+};
+type AppearanceTraits = {
+    readonly female: boolean;
+    readonly tone: number;
+    readonly topColor: number;
+    readonly pantsColor: number;
+    readonly sleeve: string;
+    readonly hair: string;
+    readonly headWidth: number;
+    readonly headHeight: number;
+    readonly jaw: number;
+    readonly nose: number;
+    readonly beard: boolean;
+    readonly glasses: boolean;
+    readonly cap: boolean;
+    readonly capColor: number;
+    readonly bag: boolean;
+    readonly bagColor: number;
+    readonly torn: boolean;
+    readonly apron: boolean;
+    readonly hairColor: number;
+    readonly shoeColor: number;
+};
+type DrawnAppearance = {
+    readonly traits: AppearanceTraits;
+    /** The stream, positioned after the look: the body builder keeps drawing from it (the hair of a decrepit body). */
+    readonly random: () => number;
+};
+/** The seed of the blood stream (the same drips on every level of detail). */
+declare const BLOOD_SEED_OFFSET = 99;
+declare const createBloodStream: (seed: number) => (() => number);
+/**
+ * A person's look from a seed, drawing in exactly the order the Bestiário v17 builder draws from its `VR` stream, including the draws a
+ * short-circuit skips (no beard roll for a woman, no cap roll under a hat). Returns the stream so the builder can continue from it.
+ */
+declare const drawAppearance: (params: AppearanceParams) => DrawnAppearance;
+
+/** P = √(E·m/A) against the resistance of the path; a protection layer stops a projectile whose force is not above its resistance. */
+declare const PHYSICAL_PENETRATION: PenetrationModel;
+/** The game's rule: pistol-class rounds are stopped by a vest or a helmet; the skull is pierced within the calibre's `cranio` range. */
+declare const TEAM_GAME_PENETRATION: PenetrationModel;
+declare const PENETRATION_MODELS: {
+    readonly physical: PenetrationModel;
+    readonly 'team-game': PenetrationModel;
+};
+/** Resistance of a torso path: flesh 22 cm × 0.25 + bone 2 cm × 1.0 = 7.5. */
+declare const TORSO_RESISTANCE: number;
+type ResistanceParams = {
+    readonly kind: SegmentKind;
+    readonly bodyCount: number;
+    readonly protection: number;
+};
+/** R of the path through a segment: torso 7.5 (× the body count of a brute), head 0.7×, limbs 0.5×, plus the protection worn over it. */
+declare const segmentResistance: ({ kind, bodyCount, protection }: ResistanceParams) => number;
+/** Share of the energy a projectile of force `force` keeps after a path of resistance `resistance`: P/(P+R). */
+declare const energyKept: (force: number, resistance: number) => number;
+/** Penetration points a region costs in the game (`custo`): head 0.7, torso 1 (a brute 2), limb 0.5. */
+declare const teamGameCost: (region: BodyRegion, bodyCount: number) => number;
+/** The game's falloff: full damage up to the effective range, then linear down to half at twice the range, never below half. */
+declare const teamGameFalloff: (distance: number, range: number) => number;
+
+/** Deterministic mulberry32 stream in [0, 1). */
+declare const createRng: (seed: number) => (() => number);
+/** Damage points of a blow from its energy in joules: `coefficient · E^exponent` (9×19 → 35, 7.62×39 → 59, .308 → 71.7). */
+declare const pointsFromEnergy: (energy: number, rules: Pick<DamageRules, "points">) => number;
+/** The caller's points, else the calibre table's, else the energy formula. */
+declare const resolvePoints: (hit: BodyHit, caliber: CaliberEntry | undefined, rules: Pick<DamageRules, "points">) => number;
+/** One draw of ±`spread` on the points (none when the spread is 0, so the stream is not touched). */
+declare const spreadPoints: (points: number, spread: number, random: () => number) => number;
+/** P = √(E·m/A): E in joules, m in grams, A the cross-section in mm². */
+declare const penetrationForce: (energy: number, grams: number, diameterMm: number) => number;
+/** What a ballistic hit is (force, class, skull range, pellets, distance), from the hit and the calibre table. */
+declare const projectileOf: (hit: BodyHit, caliber: CaliberEntry | undefined) => ProjectileInfo;
+/** `hit.cut`, else the default of its damage type (a bullet by class: pistol 0.15, buckshot 0.75, rifle 0.45). */
+declare const cutOf: (hit: BodyHit, projectile: ProjectileInfo | undefined, rules: Pick<DamageRules, "defaultCut">) => number;
+
+/** The layered protection of T3: `1 − Π(1 − value·condition)`, at most `cap`. */
+declare const LAYERED_PROTECTION_CAP = 0.9;
+type LayeredProtectionParams = {
+    readonly layers: readonly ProtectionLayer[];
+    readonly attack: 'bite' | 'scratch';
+    /** 0..1 condition per layer id (worn, torn); 1 by default. */
+    readonly conditions?: Readonly<Record<string, number>>;
+};
+declare const layeredProtection: ({ layers, attack, conditions }: LayeredProtectionParams) => number;
+/** The layers worn that cover any of `slots` and are not used up. */
+declare const layersOn: (worn: readonly ProtectionLayer[], slots: readonly BodySlot[], consumed: ReadonlySet<string>) => ProtectionLayer[];
+/** What the layers over a segment do to one blow. */
+type ProtectionOutcome = {
+    /** A consumable layer took the whole projectile (a helmet): no damage, and the layer is used up. */
+    readonly absorbedBy?: string;
+    /** Share of the points that gets through the ballistic layers. */
+    readonly ballistic: number;
+    /** Penetration resistance the layers add (the `physical` model). */
+    readonly resistance: number;
+    /** Factor on limb damage (a turnout coat). */
+    readonly limbs: number;
+    /** Factor on fire damage. */
+    readonly fire: number;
+};
+type ProtectParams = {
+    readonly layers: readonly ProtectionLayer[];
+    readonly projectile?: ProjectileInfo;
+    readonly model: PenetrationModel;
+};
+/** A stopped projectile does the layer's `blunt` share; one that goes through, `pass` (default `blunt`). Non-projectiles ignore ballistic layers. */
+declare const protect: ({ layers, projectile, model }: ProtectParams) => ProtectionOutcome;
+
+export { ARSENAL_RULES, type AgeGroup, type AnimateProfileParams, palette as AppearancePalette, type AppearanceParams, type AppearanceTraits, BLOOD_LITERS_PER_DROP, BLOOD_SEED_OFFSET, BODY_MATERIAL, BODY_REGIONS, type BallisticClass, type BlastRules, type Bleeder, type BodyHit, type BodyMultipliers, type BodySpec, type BodyVariance, type BuildClass, CASCADE, CRAWL_TILT_RATE, type CaliberEntry, type CascadeJoint, type Character, type CharacterKit, type CharacterPack, type CharacterPreset, type CharacterSpec, type CharactersOptions, type ConditionOptions, type ConditionPhase, type ConditionSample, type ConditionTimeline, type CorpseEntry, type CorpseLedger, type CorpseOptions, type CrawlPose, type CreateRigParams, DAMAGE_PRESETS, DEAD_TILT_RATE, DEFAULT_CORPSES, DEFAULT_DAMAGE_RULES, type DamageCharacter, type DamageOptions, type DamageRules, type DeadPose, type DeathRule, type Detail, type DrawnAppearance, ELENCO_RULES, GAME_BONES, GUIDE, type GaitProfile, type GaitSample, type HairStyle, type HitReport, type HumanArm, type HumanPose, type HumanPoseParams, INSTANCE_POSES, type InstancePose, JOINT_IDS, JOINT_PARENTS, type JointAngles, type JointId, LAYERED_PROTECTION_CAP, LIMB_REGIONS, LIMP, type LegAngles, type LimbRegion, type LineHit, type LineResult, type LineShot, type LineTarget, MOVES, MOVE_BLEND_RATE, type MoveBlend, type MoveId, type OutfitLook, PENETRATION_MODELS, PERSON_PRESET, PHYSICAL_PENETRATION, PROTECTION_PRESETS, type PenetrateLineParams, type PenetrationModel, type ProjectileInfo, type ProtectionLayer, type ProtectionOutcome, REGION_HIT_POINTS, REGION_SEGMENTS, type ResolvedCharacterSpec, type RestPose, type Rig, SEGMENT_IDS, SEGMENT_NUMBERS, SEGMENT_TREE, type SegmentId, type SegmentNode, type SegmentNumbers, type SegmentRuleId, type SegmentSide, type SegmentState, type SegmentStatus, type SeverityRules, type Stride, type StrideParams, TEAM_GAME, TEAM_GAME_CALIBERS, TEAM_GAME_CALIBER_KEYS, TEAM_GAME_PENETRATION, TORSO_RESISTANCE, type VarianceScale, animateProfile, applyPatches, applyPreset, bleedRateAt, blendMoves, crawlPose, createBloodStream, createBodySpec, createCharacters, createConditionTimeline, createCorpseLedger, createRig, createRng, cutOf, deadPose, decodePoseHeight, describeBody, drawAppearance, drawBodyVariance, emptySample, encodePoseHeight, energyKept, humanPose, isBodyRegion, isSegmentId, layeredProtection, layersOn, lerpPose, mergeById, moveBlendOf, penetrateLine, penetrationForce, pointsFromEnergy, projectileOf, protect, removeIds, resolveDamageRules, resolvePoints, segmentNode, segmentResistance, segmentsBelow, spreadPoints, stepCascade, strideFor, teamGameCost, teamGameFalloff, variantCountFor, variantDecay, variantSeed, walkCadence, walkGait };