@adatechnology/game-player 0.4.0 → 0.5.0

package/dist/testing-CD4p4NR5.d.ts

@@ -0,0 +1,430 @@
+import { BlowId, BodyFoleyId, SurfaceId, TestableModule } from '@adatechnology/game-contracts';
+
+var numbers = {
+	hurtFlash: 0.4,
+	hurtVolume: 0.8,
+	biteDamage: 25,
+	biteFlash: 0.8,
+	biteVolume: 1.2,
+	burnPerSecond: 3,
+	bleedPerSecond: 0.15,
+	grabSeconds: 3,
+	grabVolume: 1,
+	grabFollow: 12,
+	grabOffset: 0.55,
+	grabPushCost: 6,
+	grabPushMinStamina: 5,
+	grabPushVolume: 1.5,
+	grabPushes: 6,
+	grabPushStun: 1.2,
+	grabPushSpeed: 3,
+	grabKnifeChance: 0.7,
+	grabKnifeRegion: 0,
+	grabKnifeDamage: 22,
+	grabKnifeDistance: 0.5,
+	grabKnifeCut: 0.7,
+	drownDamage: 30,
+	drownFlash: 0.8,
+	noJawDamage: 8,
+	grabAttackCooldown: 2,
+	vaultSeconds: 0.7,
+	vaultCost: 15,
+	vaultHeight: 1.9,
+	vaultScanFrom: 0.3,
+	vaultScanTo: 1,
+	vaultScanStep: 0.1,
+	vaultLandFrom: 0.4,
+	vaultLandTo: 1.4,
+	vaultClearance: 0.3,
+	vaultCheckHeight: 0.4,
+	vaultNoise: 6,
+	vaultStartVolume: 0.8,
+	vaultLandVolume: 1,
+	crouchSpeed: 1,
+	walkFactor: 1.35,
+	aimSpeedCap: 1.4,
+	waterSpeed: 0.55,
+	runMinStamina: 1,
+	runDrain: 12,
+	regenMoving: 4,
+	regenStill: 8,
+	acceleration: 10,
+	radius: 0.3,
+	blockHeight: 0.4,
+	pushApartRadius: 0.55,
+	pushApartHeight: 1.2,
+	hipFollow: 10,
+	hipMinSpeed: 0.3,
+	hipLimit: 0.9,
+	backwardsBelow: -0.1,
+	cadenceBase: 0.5,
+	cadencePerSpeed: 0.3,
+	cadenceMinSpeed: 0.05,
+	turnFollow: 12,
+	stepEvery: 0.75,
+	stepMinSpeed: 0.3,
+	stepNoiseRun: 8,
+	stepNoiseWalk: 3,
+	stepNoiseCrouch: 1,
+	stepNoiseWater: 2,
+	stepVolumeRun: 0.6,
+	stepVolumeWalk: 0.3,
+	shoveCost: 10,
+	shoveVolume: 1.2,
+	shoveRange: 1.6,
+	shoveCone: 0.3,
+	shoveStun: 0.9,
+	shoveSpeed: 2.5,
+	meleeMinStamina: 5,
+	meleeCostLight: 5,
+	meleeCostHeavy: 12,
+	meleeHeavyKg: 1.5,
+	meleeVolume: 0.6,
+	meleeRangeBase: 0.9,
+	meleeCone: 0.5,
+	meleeHeadChance: 0.35,
+	meleeArmChance: 0.5,
+	meleeStrengthPerPoint: 0.06,
+	meleeStrengthBase: 5,
+	meleeCritToCut: 60,
+	panicGain: 1.2,
+	panicDecay: 3,
+	panicMax: 100,
+	panicSpreadAt: 0.6,
+	panicSpread: 1.4,
+	moveSpread: 0.4
+};
+var defaults = {
+	numbers: numbers};
+
+type AttributeId = 'strength' | 'vigor' | 'agility' | 'perception' | 'intellect' | 'presence';
+type Attributes = Readonly<Record<AttributeId, number>>;
+/** `(base + Σ coefficient × attribute) / divide`, summed left to right in the order given (the game's own order, so the floats match). */
+type LinearFormula = {
+    readonly base: number;
+    readonly terms: readonly (readonly [AttributeId, number])[];
+    readonly divide?: number;
+};
+type DerivedId = 'maxHealth' | 'maxStamina' | 'runSpeed' | 'walkSpeed' | 'footstepNoise' | 'composure';
+type DerivedFormulas = Readonly<Record<DerivedId, LinearFormula>>;
+type Derived = Readonly<Record<DerivedId, number>>;
+/** A wound kind: its share of the hits (drawn in the listed order, the last one takes the rest), its infection chance and whether it bleeds. */
+type WoundRule = {
+    readonly share: number;
+    readonly infectionChance: number;
+    readonly bleeds: boolean;
+};
+type WoundTable = Readonly<Record<string, WoundRule>>;
+/** An individual infection that runs on its own clock and kills at `deathSeconds`. Off by default: a normal world has none. */
+type InfectionRule = {
+    readonly feverSeconds: number;
+    readonly deliriumSeconds: number;
+    readonly deathSeconds: number;
+    /** Seconds after death the body turns (`turned` event). */
+    readonly reanimateSeconds: number;
+    /** With fever, every this many seconds there is a `feverNoiseChance` of a cough: noise of `feverNoiseRadius` m. */
+    readonly feverNoiseEvery: number;
+    readonly feverNoiseChance: number;
+    readonly feverNoiseRadius: number;
+    readonly feverNoiseVolume: number;
+    readonly feverSpeed: number;
+    readonly feverSpread: number;
+    /** Infection chance per wound kind; a kind left out uses the wound table's `infectionChance`. */
+    readonly chances?: Readonly<Record<string, number>>;
+};
+type PlayerNumbers = typeof defaults.numbers;
+/** What is in the hand for melee (the fist when absent): damage, critical (0..60 turns into a cut), reach in metres, noise radius, mass. */
+type MeleeItem = {
+    readonly damage: number;
+    readonly crit?: number;
+    readonly reach?: number;
+    readonly noise?: number;
+    readonly kg?: number;
+    /** How it strikes, for its sound (`game-contracts`' `BlowId`). Default: `punch` for the bare fist, `blade` when it cuts (`crit`), else `blunt`. */
+    readonly blow?: BlowId;
+};
+/** One frame of input. Held keys are booleans; the `pressed` ones are true only on the frame the key went down. */
+type PlayerInput = {
+    /** -1 back, 0, 1 forward. */
+    readonly forward?: number;
+    /** -1 left, 0, 1 right. */
+    readonly right?: number;
+    readonly run?: boolean;
+    /** Aiming down the sights: speed is capped and the body turns with the view at once. */
+    readonly aim?: boolean;
+    /** The trigger is held or the weapon is cooling: the body turns with the view at once. */
+    readonly firing?: boolean;
+    /** Where the view looks (radians, the camera's yaw: forward is `(-sin, -cos)`). */
+    readonly yaw?: number;
+    /** Held: dress the bleeding wound. */
+    readonly bandage?: boolean;
+    readonly pressed?: Readonly<Partial<Record<PlayerAction, boolean>>>;
+    /** The melee item in hand. */
+    readonly melee?: MeleeItem;
+    /**
+     * A foot of the body the host draws touched the ground this frame (its walk cycle, `HostEvent` `footfall`). From the first one on, the footsteps (their
+     * noise and their sound) follow the host's feet instead of the player's own stride timer, so the step is heard at the frame the foot is seen down.
+     */
+    readonly footfall?: boolean;
+    /** What is under the feet this frame (a surface id or a material id), when the host knows better than `world.surfaceAt`. */
+    readonly surface?: string;
+};
+type PlayerAction = 'crouch' | 'push' | 'knife' | 'vault' | 'throw';
+/**
+ * The crowd the player touches (a horde, any crowd): read by index, written through a few verbs. `game-crowd` implements it; a game with its own
+ * agents writes a small adapter. Only agents that are `active` (close and simulated every frame) are pushed, counted for panic or hit.
+ */
+interface PlayerCrowd {
+    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;
+    /** On the ground: crawling or stunned. A melee blow on it always goes to the head. */
+    down(i: number): boolean;
+    /** How much it adds to panic (default 1). */
+    panicWeight?(i: number): number;
+    /** The grabbing agent is glued to the player's body: move by `k` of the way to (x, z), stop, and face (lookX, lookZ). */
+    hold(i: number, x: number, z: number, k: number, lookX: number, lookZ: number): void;
+    stun(i: number, seconds: number, vx: number, vz: number): void;
+    /** Back to chasing, with the attack cooling for `cooldown` seconds. */
+    chase(i: number, cooldown: number): void;
+    damage(i: number, hit: {
+        region: number;
+        amount: number;
+        distance: number;
+        cut: number;
+    }): void;
+}
+/** What the player asks of the world. Everything is optional: the default is an open, dry field. */
+interface PlayerWorld {
+    /** Occupancy code of the cell at (x, z): -1 outside, 0 free, 1 solid, 2 low wall that can be vaulted, 3 open door, others solid. */
+    cellKind?(x: number, z: number): number;
+    solidAt?(x: number, z: number, y: number): boolean;
+    /** Blocks the player's body at (x, z). Default `solidAt(x, z, blockHeight)` (a roof or a floor plan passes its own). */
+    blocked?(x: number, z: number): boolean;
+    inWater?(x: number, z: number): boolean;
+    /** What is under the feet at (x, z): a surface id (`concrete`, `gravel`...) or a material id (`wood_hard`, `turf`). Default `concrete`. */
+    surfaceAt?(x: number, z: number): string | undefined;
+    /** Something else drives the player this frame (a car seat, a chair, a ladder): skip moving. */
+    busy?(dt: number): boolean;
+    /** Low walls can be vaulted here (the game says no on a roof or an upper floor). Default: only on the ground floor. */
+    canVault?(): boolean;
+    /** After the move (stairs change the floor and the height). */
+    afterMove?(player: PlayerState): void;
+    crowd?: PlayerCrowd;
+}
+type PlayerState = {
+    x: number;
+    z: number;
+    y: number;
+    vx: number;
+    vz: number;
+    /** The body's yaw (the view's yaw + π, smoothed). */
+    yaw: number;
+    floor: number;
+    alive: boolean;
+    turned: boolean;
+    health: number;
+    stamina: number;
+    crouch: boolean;
+    running: boolean;
+    stepTimer: number;
+    phase: number;
+    hip: number;
+    grabbedBy: number;
+    grabTimer: number;
+    grabPushes: number;
+    grabNoJaw: boolean;
+    grabDrown: boolean;
+    infected: boolean;
+    infectionTime: number;
+    infectionSource: string;
+    wounds: string[];
+    bleeding: number;
+    blind: number;
+    screamBoost: number;
+    panic: number;
+    hurtFlash: number;
+    deathTime: number;
+    cause: string;
+    downTimer: number;
+    burnTimer: number;
+    scentTimer: number;
+    vaultTimer: number;
+    vault: [number, number, number, number] | null;
+};
+type PlayerSoundId = 'step' | 'flesh';
+type PlayerMessageId = 'grabbed' | 'grabbed_drown' | 'bitten' | 'bandaged' | 'knife_head' | 'knife_miss' | 'pushed_off' | 'drowning' | 'no_jaw' | 'stood_up';
+type KnownDeathCause = 'infected' | 'killed' | 'bitten_to_death' | 'infection' | 'bled_out' | 'hunger_thirst' | 'drowned' | 'burned';
+/** Why the player died: the rule's own causes, or any id the host passes to `die`. */
+type DeathCause = KnownDeathCause | (string & {});
+type PlayerEventMap = {
+    noise: {
+        x: number;
+        z: number;
+        radius: number;
+    };
+    /**
+     * `sound` is the team's class (`step` or `flesh`, what the game played); `ids` are the body sounds of `game-contracts` to play together (the swing and the hit of
+     * a blow, a footstep on its surface), which `game-audio`'s `BODY_FOLEY_BANK` answers. `surface` is set for footsteps and landings.
+     */
+    sound: {
+        sound: PlayerSoundId;
+        ids: readonly BodyFoleyId[];
+        /** Seconds after now each of `ids` starts (the hit of a blow lands at the swing's loudest point); left out, all now. */
+        at?: readonly number[];
+        volume: number;
+        position: [number, number, number];
+        surface?: SurfaceId;
+    };
+    step: {
+        x: number;
+        z: number;
+        yaw: number;
+    };
+    message: {
+        id: PlayerMessageId | DeathCause;
+        seconds: number;
+    };
+    hurt: {
+        amount: number;
+        wound: string;
+    };
+    infected: {
+        source: string;
+    };
+    stage: {
+        stage: 'fever' | 'delirium';
+    };
+    died: {
+        cause: DeathCause;
+    };
+    turned: {
+        x: number;
+        z: number;
+        floor: number;
+    };
+    grabbed: {
+        by: number;
+        noJaw: boolean;
+        drown: boolean;
+    };
+    released: {
+        by: number;
+        how: 'push' | 'knife' | 'bite' | 'scratch' | 'free';
+    };
+    vault: {
+        from: [number, number];
+        to: [number, number];
+    };
+    shove: {
+        targets: number[];
+    };
+    melee: {
+        target: number;
+        region: number;
+        damage: number;
+        distance: number;
+        cut: number;
+    };
+    throw: Record<string, never>;
+};
+type PlayerEventName = keyof PlayerEventMap;
+type PlayerEvent<K extends PlayerEventName = PlayerEventName> = PlayerEventMap[K];
+type PlayerSave = {
+    readonly state: PlayerState;
+    readonly attributes: Attributes;
+};
+
+declare const PLAYER_DEFAULTS: {
+    readonly sources: Readonly<Record<string, string>>;
+    readonly attributes: Attributes;
+    readonly derived: DerivedFormulas;
+    readonly wounds: WoundTable;
+    readonly infection: InfectionRule;
+    readonly numbers: PlayerNumbers;
+    readonly fist: MeleeItem;
+};
+type PlayerOptions = {
+    /** The random stream (the game passes its single stream). Default `createRng(seed)`. */
+    readonly random?: () => number;
+    readonly seed?: number;
+    /** The sheet: every attribute 5 by default. */
+    readonly attributes?: Partial<Attributes>;
+    readonly derived?: Partial<DerivedFormulas>;
+    readonly wounds?: WoundTable;
+    /** An individual infection (`true` uses the defaults; an object patches them). Off by default: the normal world comes first. */
+    readonly infection?: boolean | Partial<InfectionRule>;
+    readonly numbers?: Partial<PlayerNumbers>;
+    readonly fist?: MeleeItem;
+    readonly position?: {
+        readonly x?: number;
+        readonly z?: number;
+        readonly yaw?: number;
+    };
+    readonly world?: PlayerWorld;
+};
+type Player = {
+    readonly state: PlayerState;
+    readonly attributes: Attributes;
+    readonly derived: Derived;
+    readonly numbers: PlayerNumbers;
+    readonly infection: InfectionRule | null;
+    update(dt: number, input?: PlayerInput, world?: PlayerWorld): void;
+    /** A hit that opens a wound (drawn from the wound table) and may infect. `by` is the agent that hit, if any. */
+    hurt(amount: number, by?: number): void;
+    /** A bite: damage, bleeding, a bite wound and (with an infection rule) the infection. */
+    bite(by?: number): void;
+    grab(by: number, noJaw?: boolean, drown?: boolean): void;
+    release(): void;
+    knock(seconds: number): void;
+    infect(source: string): void;
+    /** Kills the player with a cause (the host's deaths: a fall, a fire). */
+    die(cause: DeathCause): void;
+    /** Infection stage: `none`, `malaise`, `fever`, `delirium`. */
+    stage(): 'none' | 'malaise' | 'fever' | 'delirium';
+    /** Seconds the infection has left, or null. */
+    timeLeft(): number | null;
+    /** What the player's state does to aim spread (panic, fever, moving); the weapon multiplies its own spread by it. */
+    spreadFactor(): number;
+    /** The agents in front (nearest first) within `range` m and a cone of `cosMin`, as `[distance, index]`. */
+    front(range: number, cosMin: number, yaw: number, crowd?: PlayerCrowd): [number, number][];
+    on<K extends PlayerEventName>(event: K, listener: (event: PlayerEventMap[K]) => void): () => void;
+    save(): PlayerSave;
+    load(save: PlayerSave): void;
+    /** The world `update` uses when it is given none. */
+    setWorld(world: PlayerWorld): void;
+};
+/** The derived values of a sheet (the game's `DERIV`). */
+declare const deriveVitals: (attributes: Attributes, formulas?: DerivedFormulas) => Derived;
+/** Which wound a hit opens: one draw, the kinds in the listed order, the last one takes the rest (the game's `FERIDA` draw). */
+declare const drawWound: (wounds: WoundTable, random: () => number) => string;
+/**
+ * The player body: a literal port of the team game's `player` and `playerUpdate` (G 68427-68640) with the world, the crowd and the input as
+ * arguments instead of globals. The draws on `random` happen in the game's order (wound kind, infection, the fever cough, the knife when grabbed,
+ * the melee region), so a game that passes its own stream keeps its sequence.
+ */
+declare function createPlayer(options?: PlayerOptions): Player;
+
+type PlayerTestModuleOptions = PlayerOptions & {
+    readonly locale?: string;
+};
+/** What the scenarios use of the context the test room passes. */
+interface PlayerScenarioLike {
+    expect(condition: boolean, label: string, data?: Record<string, unknown>): void;
+}
+type PlayerTestModule = TestableModule<PlayerScenarioLike> & {
+    /** The player in use (replaced when the bench changes the sheet, the seed or the infection). */
+    readonly player: Player;
+};
+/**
+ * The player area of a test room, against the generic contracts only. The room's camera is the player: where it walks, the player walks; its speed
+ * decides walking or running, so stamina, footsteps and their noise follow the viewer. The bench hurts, bites, grabs and knocks the player down,
+ * switches the individual infection (off by default: a normal world) and sets the sheet. Footsteps and flesh sounds go to `host.audio`.
+ */
+declare function createPlayerTestModule(options?: PlayerTestModuleOptions): PlayerTestModule;
+
+export { type AttributeId as A, type DeathCause as D, type InfectionRule as I, type KnownDeathCause as K, type LinearFormula as L, type MeleeItem as M, type PlayerMessageId as P, type WoundRule as W, type Attributes as a, type Derived as b, type DerivedFormulas as c, type DerivedId as d, PLAYER_DEFAULTS as e, type Player as f, type PlayerAction as g, type PlayerCrowd as h, type PlayerEvent as i, type PlayerEventMap as j, type PlayerEventName as k, type PlayerInput as l, type PlayerNumbers as m, type PlayerOptions as n, type PlayerSave as o, type PlayerSoundId as p, type PlayerState as q, type PlayerTestModule as r, type PlayerTestModuleOptions as s, type PlayerWorld as t, type WoundTable as u, createPlayer as v, createPlayerTestModule as w, deriveVitals as x, drawWound as y };

package/dist/testing.d.ts

@@ -0,0 +1,2 @@
+export { r as PlayerTestModule, s as PlayerTestModuleOptions, w as createPlayerTestModule } from './testing-CD4p4NR5.js';
+import '@adatechnology/game-contracts';

package/dist/testing.js

@@ -0,0 +1,7 @@
+import {
+  createPlayerTestModule
+} from "./chunk-FRZ6ISLA.js";
+export {
+  createPlayerTestModule
+};
+//# sourceMappingURL=testing.js.map

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adatechnology/game-player",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "license": "MIT",
   "description": "Pure, seeded player body for games: vitals from an attribute sheet, stamina, wounds and bleeding, an optional individual infection, being grabbed and breaking free, knock-downs, low-wall vaults, footstep noise, panic, shove and melee against any crowd. A literal port of the team game's player. Knows nothing about any game.",
   "keywords": [
@@ -32,13 +32,17 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js"
+    },
     "./global": "./dist/index.global.js"
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@adatechnology/game-contracts": "^0.20.0"
+    "@adatechnology/game-contracts": "^0.22.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.7",