@adatechnology/game-crowd-three 0.3.8 → 0.4.0

package/dist/testing-sTAa84Ib.d.ts

@@ -0,0 +1,442 @@
+import { CrowdStore, Corpse, Civilian, Crowd, CrowdType, Herd, Flock, CrowdUpdateContext, CrowdPack, InfectionModelLike, CrowdPhysicsOptions } from '@adatechnology/game-crowd';
+import { IdentityLook, BodyVariant, BakeBuilders, BakeSpec, KitAccessory, Three } from '@adatechnology/game-characters-three';
+import { ModuleHost, TestableModule } from '@adatechnology/game-contracts';
+import { Player } from '@adatechnology/game-player';
+import * as THREE_NS from 'three';
+import { InstancePose } from '@adatechnology/game-characters';
+
+var numbers = {
+	lodDistances: [
+		18,
+		55
+	],
+	lodHysteresis: 1.5,
+	behindFrom: 30,
+	behindFactor: 0.35,
+	behindMargin: 3,
+	farCull: 200,
+	gaitMax: 1.4,
+	attackEnter: 2.56,
+	attackLeave: 4.84,
+	swell: 0.9,
+	swellPivot: 0.5,
+	ageBase: 0.75,
+	agePer: 0.08,
+	armBase: 1,
+	armPer: 0.4,
+	corpseNear: 18,
+	corpseFade: 60,
+	corpseDarken: 0.7,
+	corpseRise: 1.8,
+	corpseAgeBase: 0.8,
+	corpseAgeDark: 0.2,
+	childHeight: 0.66,
+	childBuild: 0.75,
+	bittenLook: 0.3,
+	civilianSkinStep: 0.25,
+	civilianBake: 0.8,
+	civilianBatch: 4
+};
+var poses = {
+	dormant: "fallen",
+	airborne: "leap",
+	eating: "eat",
+	pileStep: "attack",
+	swing: "scream",
+	crawl: "crawl",
+	grab: "attack",
+	calling: "scream",
+	"default": "walk",
+	corpse: "fallen",
+	civilian: "walk"
+};
+var defaults = {
+	numbers: numbers,
+	poses: poses
+};
+
+/** The numbers of the look a body is given from its identity (T4b.7, D11). Every one is a default a game can change. */
+declare const VARIETY_DEFAULTS: {
+    readonly capChance: 0.16;
+    readonly backpackChance: 0.2;
+    readonly hoodChance: 0.1;
+    /** Chance of a wound in a region at the youngest infection age, and how much each age step adds. */
+    readonly woundBase: 0.05;
+    readonly woundPerAge: 0.12;
+    /** Share of the wounds that are severe. */
+    readonly severeShare: 0.35;
+    /** Steps of the infection age of the pack (0 .. ageSteps). */
+    readonly ageSteps: 3;
+    /** How much of a shove's push (0..1) tilts the body. */
+    readonly leanScale: 0.3;
+};
+type CrowdVarietyNumbers = {
+    readonly [K in keyof typeof VARIETY_DEFAULTS]: number;
+};
+/** The whole look of an agent, all of it from its identity and its state in the store: it never changes with the level of detail. */
+declare const lookOfAgent: (store: CrowdStore, i: number, N: CrowdVarietyNumbers, extra?: Pick<IdentityLook, "clipA" | "clipB" | "clipBlend" | "clipSpeed" | "clips">) => IdentityLook;
+
+type CrowdRenderNumbers = typeof defaults.numbers;
+type CrowdPoseMap = {
+    readonly [K in keyof typeof defaults.poses]: InstancePose;
+};
+/** The game's numbers for the drawing (G 67098 `hordeRender`, G 70177 `npcRender`) and the instance pose of each state. */
+declare const CROWD_RENDER_DEFAULTS: {
+    readonly sources: Readonly<Record<string, string>>;
+    readonly numbers: CrowdRenderNumbers;
+    readonly poses: CrowdPoseMap;
+};
+/**
+ * One body for a batch: the 12 numbers of the shader's `iA`, `iB` and `iC` (`a`: x, z, yaw, phase; `b`: height and build over the variant's,
+ * stride, pose; `c`: missing parts, age look, arms, skin), the shirt colour as hex with the shade it is multiplied by, the eye colour (none:
+ * no glow) and the ground height.
+ */
+type CrowdInstance = {
+    readonly a: readonly [number, number, number, number];
+    readonly b: readonly [number, number, number, number];
+    readonly c: readonly [number, number, number, number];
+    readonly color: number;
+    readonly shade: number;
+    readonly eye: number | null;
+    readonly y: number;
+    /** The identity `iD` (with `variety`): wounds, trousers, gait style, accessories, clips, lean. See `packIdentity`. */
+    readonly d?: readonly [number, number, number, number];
+    /** The accessory bits of the look (with `variety`), so a renderer routes the instance to the accessory batches. */
+    readonly accessories?: number;
+    /** The crowd type index of the agent (with `variety`). */
+    readonly type?: number;
+};
+/** A baked variant as the drawing reads it: its own height and build (the instance scales the agent's against them). */
+type VariantSize = {
+    readonly s: number;
+    readonly bulk: number;
+};
+/** Where the frame is seen from. `target` is who the agents attack (the attack pose); `hidden` leaves an agent out (a floor the viewer is not on). */
+type CrowdFrame = {
+    readonly camera: {
+        readonly x: number;
+        readonly z: number;
+    };
+    /** The view's yaw: forward is `(-sin, -cos)`. */
+    readonly viewYaw: number;
+    readonly target?: {
+        readonly x: number;
+        readonly z: number;
+        readonly alive: boolean;
+    } | null;
+    readonly hidden?: (i: number) => boolean;
+    /** How much of the level budget to use this frame, 0..1 (default 1); the renderer lowers it when the frames run long. */
+    readonly detailScale?: number;
+};
+/** Takes one instance for the batch of `variant` at level `level` (0 near, 1 middle, 2 far). */
+type CrowdInstanceSink = (variant: number, level: number, instance: CrowdInstance) => void;
+/** Takes one body on the ground that was not an agent (a civilian killed outright): the plain body batch. */
+type PlainCorpseSink = (instance: CrowdInstance) => void;
+type CrowdInstancesOptions = {
+    readonly numbers?: Partial<CrowdRenderNumbers>;
+    readonly poses?: Partial<CrowdPoseMap>;
+    /** The eye colour of each crowd type, by type index (G `_eye`); null for a type that has none. */
+    readonly eyes: readonly (number | null)[];
+    /** Identity for every agent (T4b.7), default off: each instance carries `d`, `accessories` and `type`, and the stagger pose; the game's numbers do not change. */
+    readonly variety?: {
+        readonly numbers?: Partial<CrowdVarietyNumbers>;
+        readonly impostorFrom?: number;
+        readonly segmentClips?: boolean;
+        readonly budget?: readonly number[];
+    };
+};
+type CrowdInstances = {
+    readonly numbers: CrowdRenderNumbers;
+    /** Writes the agents seen this frame, keeps each one's level of detail and attack pose in the store (`lod`, `attackPose`) and returns how many went out. */
+    agents(store: CrowdStore, variants: readonly VariantSize[], frame: CrowdFrame, sink: CrowdInstanceSink): number;
+    /** Writes the bodies on the ground: an agent's on its variant, the others on the plain batch. `life` is the seconds a body lasts (the crowd's `corpseSeconds`). */
+    corpses(entries: readonly {
+        readonly age: number;
+        readonly data: Corpse;
+    }[], variants: readonly VariantSize[], frame: CrowdFrame, life: number, sink: CrowdInstanceSink, plain: PlainCorpseSink): void;
+    /** Writes the civilians that are still people (not dead, turned or gone); `colorOf` gives each one's shirt. */
+    civilians(list: readonly Civilian[], colorOf: (civilian: Civilian) => number, sink: (civilian: Civilian, instance: CrowdInstance) => void): void;
+};
+/**
+ * The drawing of a crowd as instances, without three.js: a literal port of the team game's `hordeRender` (G 67098-67136) and `npcRender`
+ * (G 70177-70184). The renderer of `game-crowd-three` hands each instance to a `BodyBatch` of `game-characters-three`; any other drawing can take them.
+ */
+declare function createCrowdInstances(options: CrowdInstancesOptions): CrowdInstances;
+
+/** Variety on the instanced path (T4b.7, D11 and D12): identity for every body, accessories, real shadows only near and blobs beyond. Absent, the renderer is the game's. */
+type CrowdRendererVariety = {
+    readonly numbers?: Partial<CrowdVarietyNumbers>;
+    /** The accessory batches, drawn by the kit's builders (default `KIT_ACCESSORIES`); `false` for none. */
+    readonly accessories?: readonly KitAccessory[] | false;
+    /** Instances an accessory batch holds at the near and the middle level (default 480 and 1400). */
+    readonly accessoryCapacity?: readonly [number, number];
+    /** Only the nearest level casts a real shadow (default true). */
+    readonly nearShadows?: boolean;
+    /** Draws the depth of the near level first so its lit pass shades each pixel once (default true): the room's lights make an overdrawn fragment the dearest part of a crowd close to the camera. */
+    readonly nearDepthPrepass?: boolean;
+    /** One dark disc under each body beyond the nearest level (default true). */
+    readonly blobShadows?: boolean;
+    /** Walk the bodies of the near and middle levels from the clip texture (12 bones, 24 texels, nearest filtered; step 3 of the ladder). Default off: the shader's own walk. */
+    readonly segmentClips?: boolean;
+    /**
+     * How many bodies each mesh level may draw (default 160, 320 and 600 for the near, middle and far levels, and half of the near budget for the bodies on the ground that keep the near mesh; `false` for the nominal distances only). A crowd packed near the camera pulls the edges in,
+     * so the bodies past a level's budget draw at the next one, and the last go to the impostor. Under `adapt` the budget shrinks while the crowd takes the GPU longer than `gpuHighMs` and grows back under `gpuLowMs` (timer queries; where the
+     * GPU has none, while the frames run longer than `highMs` and back under `lowMs`).
+     */
+    readonly budget?: false | {
+        readonly levels?: readonly number[];
+        readonly adapt?: false | {
+            readonly gpuHighMs?: number;
+            readonly gpuLowMs?: number;
+            readonly highMs?: number;
+            readonly lowMs?: number;
+            readonly minScale?: number;
+        };
+    };
+    /** The far tier (default on, from 90 m): one atlas for every type, one draw call; `false` keeps the far mesh to the cull distance. */
+    readonly impostor?: false | {
+        readonly from?: number;
+        readonly capacity?: number;
+        readonly light?: {
+            readonly r: number;
+            readonly g: number;
+            readonly b: number;
+        };
+    };
+};
+type CrowdRendererOptions = {
+    readonly crowd: Crowd;
+    /** The rich builders the bodies are baked from (`game-characters-three`: the Bestiário builder, optionally the survivors'). */
+    readonly builders: BakeBuilders;
+    /** The name the rich builder knows a crowd type by (default its id). */
+    readonly typeName?: (type: CrowdType, index: number) => string;
+    /** The civilians to draw and the body each one is baked from (G 68469 `PB`: a human spec or a portrait). Without it no civilian is drawn. */
+    readonly civilians?: {
+        readonly list: () => readonly Civilian[];
+        readonly body: (civilian: Civilian) => BakeSpec;
+        readonly color?: (civilian: Civilian) => number;
+    };
+    /** The plain body for bodies on the ground that were not agents (default the instanced body at the middle level, G `BODY_LOD[1]`). */
+    readonly plainBody?: THREE_NS.BufferGeometry;
+    /** Whether the bodies on the ground are drawn this frame (default always). */
+    readonly drawCorpses?: () => boolean;
+    readonly numbers?: Partial<CrowdRenderNumbers>;
+    readonly poses?: Partial<CrowdPoseMap>;
+    readonly variety?: CrowdRendererVariety;
+};
+type CrowdRenderer = {
+    /** Holds every batch; add it to the scene. */
+    readonly group: THREE_NS.Group;
+    readonly instances: CrowdInstances;
+    /** Bakes every type's variants now (otherwise a type is baked the first time one of its bodies is drawn). */
+    bake(): void;
+    /**
+     * Bakes and makes every batch the frame would make on demand (the bodies on the ground, the blob shadows, the impostors, the accessories of the near and middle levels), so that a host that compiles
+     * its scene (`ProgramWarmup`) links the body, accessory, blob and impostor programs and their depth and distance materials before play, and no batch is made during it.
+     */
+    prepare(): void;
+    /** Draws the frame: the agents, the bodies on the ground and the civilians. */
+    update(dt: number, frame: CrowdFrame): void;
+    /** Agents drawn at each level of detail in the last frame (G `lodCounts`). */
+    readonly lodCounts: readonly [number, number, number];
+    /** The share of the level budget in use, 1 down to the adaptive floor. */
+    readonly detailScale: number;
+    /** The smoothed GPU time of the crowd's draws in milliseconds (0 until the timer answers, or without one). */
+    readonly gpuMs: number;
+    /** Agents drawn as impostors in the last frame. */
+    readonly impostorCount: number;
+    /** Batches with something to draw. */
+    readonly drawCalls: number;
+    readonly bakeMs: number;
+    readonly variants: readonly BodyVariant[];
+    dispose(): void;
+};
+/**
+ * The crowd drawn on the instanced path: every type's variants baked at the three levels of detail (G 67079 `ZVAR`, the variants and seeds of
+ * `game-characters`), a few draw calls for thousands of agents, the bodies on the ground and the civilians. The instances are `createCrowdInstances`
+ * (the port of `hordeRender` and `npcRender`); the batches are `game-characters-three`'s.
+ */
+declare function createCrowdRenderer(three: Three, options: CrowdRendererOptions): CrowdRenderer;
+
+/** One drawn animal, as `game-animals-three` builds it (structural: this package does not depend on it). */
+type DrawnAnimal = {
+    readonly root: THREE_NS.Object3D;
+    readonly wings: readonly {
+        readonly shoulder: THREE_NS.Object3D;
+        readonly elbow: THREE_NS.Object3D;
+        readonly side: number;
+    }[];
+    phase: number;
+};
+/** What draws the animals: `game-animals-three`'s `createAnimalsThree(THREE)` is one as it is. */
+type AnimalDrawer<TSpecies = unknown> = {
+    build(species: TSpecies, options?: {
+        readonly phase?: number;
+    }): DrawnAnimal;
+    animate(rig: DrawnAnimal, params: {
+        readonly time: number;
+        readonly delta: number;
+        readonly clip: string;
+    }): void;
+    setVisualState?(rig: DrawnAnimal, state: 'alive' | 'infected' | 'dead'): void;
+};
+type HerdViewOptions<TSpecies> = {
+    readonly herd: Herd;
+    readonly drawer: AnimalDrawer<TSpecies>;
+    /** The species card of an animal's species id (`game-animals-species` `getSpecies`). */
+    readonly species: (id: string) => TSpecies | undefined;
+    /** The vultures: the flock that moves the herd's sky animals, in the order they were added. */
+    readonly flock?: Flock;
+};
+type HerdView = {
+    readonly group: THREE_NS.Group;
+    /** Builds what is new in the herd and moves every drawn animal to its place this frame (G 66697-66708). */
+    update(dt: number): void;
+    readonly count: number;
+    clear(): void;
+};
+/**
+ * The herd drawn with the animals' own rigs: each animal where `game-crowd`'s herd put it, turned to its heading and animated with its clip (G 66697
+ * `E.pele.mesh.position.set(E.x, 0, E.z)`, `animQuad`); the vultures where the flock puts them, gliding with the wings half open (G 66704-66708).
+ */
+declare function createHerdView<TSpecies>(three: {
+    readonly Group: new () => THREE_NS.Group;
+}, options: HerdViewOptions<TSpecies>): HerdView;
+
+/** The ground a scene lays out its things on: the crowd area centre. */
+type CrowdScenePlace = {
+    readonly cx: number;
+    readonly cz: number;
+};
+/** What the host project lends the scenes to draw with: its wall piece and the ids of the catalogue items it has (`ModuleHost.addObject`). Without them a scene only writes the grid. */
+type CrowdSceneProps = {
+    /** An Object3D wall of this length and height, base at the origin along x (the kit's `wallPiece`). */
+    readonly wall?: (three: typeof THREE_NS, size: {
+        readonly length: number;
+        readonly height: number;
+    }) => THREE_NS.Object3D | undefined;
+    /** Item ids of the host's catalogue: the gas cylinder, the car and the car's fuel tank. */
+    readonly items?: {
+        readonly gasCylinder?: string;
+        readonly car?: string;
+        readonly carTank?: string;
+    };
+};
+/** A place for the crowd to be born in, with the walls and doors of its own. The bench applies it after the seed and before the physics and the count. */
+interface CrowdBenchScene {
+    readonly id: string;
+    /** Writes the walls and the doors of the scene to the crowd's grid. */
+    layout(crowd: Crowd, place: CrowdScenePlace): void;
+    /** Bears `count` agents of `type` (-1: the pack's mix), the `first`-th of the scene onwards; `unit` is the seeded stream of the scene. */
+    spawn(crowd: Crowd, request: {
+        readonly first: number;
+        readonly count: number;
+        readonly type: number;
+        readonly unit: () => number;
+    }, place: CrowdScenePlace): void;
+    /** The context of `crowd.update`: where the bands are centred and where the flow converges. */
+    context?(place: CrowdScenePlace): Pick<CrowdUpdateContext, 'bandCentre' | 'flowTarget'>;
+    /** Where the camera stands to see the scene. */
+    view(place: CrowdScenePlace): {
+        readonly eye: readonly [number, number, number];
+        readonly target: readonly [number, number, number];
+    };
+    /** Puts the scene's things in the host's world; returns what takes them away. */
+    props?(host: ModuleHost, place: CrowdScenePlace, props: CrowdSceneProps): () => void;
+}
+/** A horde pressed against a wall of 30 m with a door of 1.2 m, born behind it; the player stands on the other side. */
+declare const DENSE_WALL: CrowdBenchScene;
+/** A horde coming down a street of 12 m at a row of six gas cylinders and a car; the player stands at the end of the street. */
+declare const CHAIN_LINE: CrowdBenchScene;
+declare const BUILTIN_SCENES: Readonly<Record<string, CrowdBenchScene>>;
+
+declare const CROWD_AREA_ID = "crowd_area";
+/** The species card the bench reads: the gait rates (`game-animals-species` cards are these). */
+type CrowdBenchSpecies = {
+    readonly walkHz: number;
+    readonly runHz: number;
+};
+/** What a crowd effect is in the host's effect catalogue (`host.effects`): its id and, optionally, the option it plays with. */
+type CrowdEffectMap = Readonly<Record<string, {
+    readonly effect: string;
+    readonly param?: number | string;
+} | null>>;
+/** The room's effects for the crowd's (the Oficina de VFX recipes of `game-vfx`): blood on a hit, a severed limb, the bloater's cloud, a spark, dust. */
+declare const CROWD_EFFECTS: CrowdEffectMap;
+type CrowdTestModuleOptions = {
+    readonly locale?: string;
+    /** The bodies the crowd draws from (types, ages, outfits): the host's content (`game-characters-undead` `undeadCrowdPack()`, or a game's own). */
+    readonly pack: CrowdPack;
+    /** The rich builders the bodies are baked from, made once three.js is lent. Without it the crowd runs and nothing is drawn. */
+    readonly builders?: (three: Three) => BakeBuilders;
+    /** The name the rich builder knows a type by (default its id). */
+    readonly typeName?: (type: CrowdType, index: number) => string;
+    /** The bench's name of a type (default its id). */
+    readonly typeLabel?: (type: CrowdType, locale: string) => string;
+    /** The bodies of the civilians (baked human specs), one per civilian, in order; without them the civilians run but are not drawn. */
+    readonly civilianBodies?: readonly BakeSpec[];
+    /** The animals: the species card of an id, its size (`game-animals` `quadrupedLayout(body).size`, `birdSize(body)`) and, optionally, what draws them. */
+    readonly animals?: {
+        readonly species: (id: string) => CrowdBenchSpecies | undefined;
+        readonly size: (species: CrowdBenchSpecies) => number;
+        readonly drawer?: (three: Three) => AnimalDrawer<CrowdBenchSpecies>;
+    };
+    /** A region model to bring agents from (`game-infection` `create(...)`) and the region the area is in. */
+    readonly infection?: {
+        readonly create: () => InfectionModelLike;
+        readonly region: string;
+        readonly active?: (model: InfectionModelLike) => number;
+    };
+    /** The effect ids of the host for the crowd's effects (default `CROWD_EFFECTS`; null leaves one out). */
+    readonly effects?: CrowdEffectMap;
+    readonly seed?: number;
+    /** Variety for the drawing (identity, accessories, near shadows, blobs): see `CrowdRendererVariety`. Default off. */
+    readonly variety?: CrowdRendererVariety;
+    /** The physics options of the crowd (personality, contact, balance...): see `CrowdPhysicsOptions`. Default off; the bench's `physics` control turns on the package defaults when this is absent. */
+    readonly crowdPhysics?: CrowdPhysicsOptions;
+    /** Scenes the bench can be born in, by id, over the built-in `dense_wall` and `chain_line`. */
+    readonly scenes?: Readonly<Record<string, CrowdBenchScene>>;
+    /** What the scenes draw with: the host project's wall piece and catalogue item ids. */
+    readonly props?: CrowdSceneProps;
+    /** Bake every type and make the drawing as soon as the module is on a frame, so the first play frame pays no bake and the room's warm-up draws the batches. Default off. */
+    readonly eager?: boolean;
+    /** Agents when the area opens (default 0, so a room that only carries the module stays calm). */
+    readonly startCount?: number;
+    /** Where the crowd is born around (default 0, -45: in front of the room's start). */
+    readonly center?: readonly [number, number];
+};
+/** What the scenarios use of the context the test room passes. */
+interface CrowdScenarioLike {
+    expect(condition: boolean, label: string, data?: Record<string, unknown>): void;
+}
+type CrowdTestModule = TestableModule<CrowdScenarioLike> & {
+    readonly crowd: Crowd;
+    readonly player: Player;
+    readonly renderer: CrowdRenderer | null;
+};
+/**
+ * The crowd area of a test room, against the generic contracts only: a horde of any pack drawn on the instanced path (the baked variants of
+ * `game-characters-three`), the room's camera as the `game-player` body it hunts, civilians, the herd and the vultures, and a bridge to a region
+ * model. Sounds go to `host.audio` (the crowd's bank is registered there), effects to `host.effects`. The pack and the bodies come in by option:
+ * this package knows no game.
+ */
+declare function createCrowdTestModule(options: CrowdTestModuleOptions): CrowdTestModule;
+
+type Keys<K extends string> = Readonly<Record<K, string>>;
+type CrowdBenchText = {
+    readonly group: string;
+    readonly name: string;
+    readonly mix: string;
+    readonly controls: Keys<'scene' | 'physics' | 'count' | 'type' | 'night' | 'seed' | 'spawn' | 'noise' | 'hit' | 'kill_all' | 'join' | 'flee' | 'herd' | 'materialize' | 'push' | 'reset'>;
+    readonly hints: Keys<'scene' | 'physics' | 'count' | 'type' | 'night' | 'noise' | 'hit' | 'join' | 'flee' | 'herd' | 'materialize' | 'push'>;
+    readonly layers: Keys<'corpses' | 'civilians' | 'animals'>;
+    readonly metrics: Keys<'agents' | 'drawn' | 'lod_near' | 'lod_middle' | 'lod_far' | 'draw_calls' | 'bake_ms' | 'active' | 'kills' | 'corpses' | 'civilians' | 'health' | 'grabbed' | 'message' | 'falls_pressure' | 'falls_chain' | 'falls_landing' | 'climbers' | 'mound_max' | 'thrown_peak' | 'max_overlap' | 'chain_links' | 'crowd_ms_p99' | 'detail_scale' | 'crowd_gpu_ms'>;
+    readonly sceneNames: Keys<'open' | 'dense_wall' | 'chain_line'>;
+    readonly scenarios: Keys<'relevance' | 'lod' | 'attack_pose' | 'corpse_darkens' | 'civilians_flee' | 'herd_calls' | 'vultures' | 'infection' | 'determinism'>;
+    readonly messages: Keys<'called' | 'burst_hit' | 'swing_knock' | 'pounce_knock' | 'migration' | 'door_broken' | 'alarm' | 'bark' | 'growl' | 'bitten' | 'turned' | 'died'>;
+    readonly yes: string;
+    readonly no: string;
+};
+declare const crowdBenchTextOf: (locale: string) => CrowdBenchText;
+
+export { type AnimalDrawer as A, lookOfAgent as B, type CrowdInstance as C, type DrawnAnimal as D, BUILTIN_SCENES as E, CHAIN_LINE as F, type CrowdBenchScene as G, type HerdView as H, type CrowdScenePlace as I, type CrowdSceneProps as J, DENSE_WALL as K, type PlainCorpseSink as P, type VariantSize as V, CROWD_AREA_ID as a, CROWD_EFFECTS as b, CROWD_RENDER_DEFAULTS as c, type CrowdBenchSpecies as d, type CrowdBenchText as e, type CrowdEffectMap as f, type CrowdFrame as g, type CrowdInstanceSink as h, type CrowdInstances as i, type CrowdInstancesOptions as j, type CrowdPoseMap as k, type CrowdRenderNumbers as l, type CrowdRenderer as m, type CrowdRendererOptions as n, type CrowdRendererVariety as o, type CrowdScenarioLike as p, type CrowdTestModule as q, type CrowdTestModuleOptions as r, type CrowdVarietyNumbers as s, type HerdViewOptions as t, VARIETY_DEFAULTS as u, createCrowdInstances as v, createCrowdRenderer as w, createCrowdTestModule as x, createHerdView as y, crowdBenchTextOf as z };

package/dist/testing.d.ts

@@ -0,0 +1,7 @@
+export { E as BUILTIN_SCENES, F as CHAIN_LINE, a as CROWD_AREA_ID, b as CROWD_EFFECTS, G as CrowdBenchScene, d as CrowdBenchSpecies, e as CrowdBenchText, f as CrowdEffectMap, p as CrowdScenarioLike, I as CrowdScenePlace, J as CrowdSceneProps, q as CrowdTestModule, r as CrowdTestModuleOptions, K as DENSE_WALL, x as createCrowdTestModule, z as crowdBenchTextOf } from './testing-sTAa84Ib.js';
+import '@adatechnology/game-crowd';
+import '@adatechnology/game-characters-three';
+import '@adatechnology/game-contracts';
+import '@adatechnology/game-player';
+import 'three';
+import '@adatechnology/game-characters';

package/dist/testing.js

@@ -0,0 +1,19 @@
+import {
+  BUILTIN_SCENES,
+  CHAIN_LINE,
+  CROWD_AREA_ID,
+  CROWD_EFFECTS,
+  DENSE_WALL,
+  createCrowdTestModule,
+  crowdBenchTextOf
+} from "./chunk-PXT6DYGJ.js";
+export {
+  BUILTIN_SCENES,
+  CHAIN_LINE,
+  CROWD_AREA_ID,
+  CROWD_EFFECTS,
+  DENSE_WALL,
+  createCrowdTestModule,
+  crowdBenchTextOf
+};
+//# 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-crowd-three",
-  "version": "0.3.8",
+  "version": "0.4.0",
   "license": "MIT",
   "description": "three.js drawing for @adatechnology/game-crowd: every agent, body on the ground and civilian as instances (a literal port of the team game's hordeRender and npcRender: view culling, LOD with hysteresis, attack pose, the pose by state), the renderer on the baked variants of game-characters-three, the herd on the animals' own rigs, the crowd's sound bank and the crowd test area.",
   "keywords": [
@@ -32,18 +32,23 @@
       "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-characters": "^0.2.6",
-    "@adatechnology/game-audio": "^0.3.5",
-    "@adatechnology/game-characters-three": "^0.7.0",
-    "@adatechnology/game-contracts": "^0.20.0",
-    "@adatechnology/game-crowd": "^0.2.6",
-    "@adatechnology/game-player": "^0.4.0"
+    "@adatechnology/game-audio": "^0.4.0",
+    "@adatechnology/game-characters": "^0.2.8",
+    "@adatechnology/game-characters-three": "^0.8.0",
+    "@adatechnology/game-contracts": "^0.22.0",
+    "@adatechnology/game-crowd": "^0.3.0",
+    "@adatechnology/game-player": "^0.5.0",
+    "@adatechnology/game-shapes-three": "^0.3.0"
   },
   "peerDependencies": {
     "three": "^0.160.0"
@@ -57,9 +62,9 @@
     "typescript": "^5.7.3",
     "vitest": "^3.2.4",
     "@adatechnology/game-animals": "^0.1.0",
-    "@adatechnology/game-animals-three": "^0.3.6",
     "@adatechnology/game-animals-species": "^0.1.0",
-    "@adatechnology/game-characters-undead": "^0.2.6",
+    "@adatechnology/game-animals-three": "^0.4.0",
+    "@adatechnology/game-characters-undead": "^0.3.0",
     "@adatechnology/game-infection": "^0.1.0",
     "@adatechnology/golden-tool": "^0.0.0"
   },