@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/navigation/builds.d.ts

@@ -0,0 +1,140 @@
+/**
+ * How Recast is told to cut the ground: what the tile cache is generated with
+ *
+ * @beta
+ */
+export interface NavigationBuildConfig {
+    cs: number;
+    ch: number;
+    tileSize: number;
+    walkableSlopeAngle: number;
+    walkableHeight: number;
+    walkableClimb: number;
+    walkableRadius: number;
+    maxSimplificationError: number;
+    mergeRegionArea: number;
+    maxVertsPerPoly: number;
+    detailSampleDist: number;
+    detailSampleMaxError: number;
+    expectedLayersPerTile: number;
+    maxObstacles: number;
+}
+/**
+ * What a navigation is built from: the ground's (or the water's) triangles, and how to cut them. Plain data, sent to a worker as it is
+ *
+ * @beta
+ */
+export interface NavigationBuild {
+    positions: Float32Array;
+    indices: Uint32Array;
+    config: NavigationBuildConfig;
+    /**
+     * How fast one on foot goes over each cell of the ground (`groundSpeedOfCell`), for a path to weigh: none where every
+     * cell is 1, which cuts the ground as it always was
+     */
+    speeds?: NavigationSpeeds;
+}
+/**
+ * Each cell's speed on the ground, row by row (`NavigationBuild.speeds`)
+ *
+ * @beta
+ */
+export interface NavigationSpeeds {
+    width: number;
+    depth: number;
+    values: Float32Array;
+}
+/**
+ * What builds a navigation: given what to build, gives back what was built (Recast's tile cache, exported). On this
+ * thread (`buildNavigationData`), or in a worker (`navigationWorker`)
+ *
+ * @beta
+ */
+export type NavigationBuilder = (build: NavigationBuild) => Promise<Uint8Array>;
+/**
+ * Where what was built is kept, by a hash of what it was built from: in memory when nothing else is said
+ * (`memoryNavigationCache`). A game keeps it elsewhere with one of its own (the browser's storage, a file)
+ *
+ * @beta
+ */
+export interface NavigationCache {
+    get(key: string): Uint8Array | undefined | Promise<Uint8Array | undefined>;
+    set(key: string, data: Uint8Array): void | Promise<void>;
+}
+/** Recast's WebAssembly, once for each thread */
+export declare const initRecast: () => Promise<void>;
+/**
+ * Builds a navigation on this thread, and gives back what was built: what a worker does too
+ *
+ * @beta
+ */
+export declare function buildNavigationData(build: NavigationBuild): Promise<Uint8Array>;
+/**
+ * Kept in memory, the last built first, up to `maxBytes` of them (64 MB when left out): a map of 512 cells a side is
+ * under a megabyte
+ *
+ * @beta
+ */
+export declare function memoryNavigationCache(maxBytes?: number): NavigationCache;
+/**
+ * What a worker is, as far as building goes: a page's `Worker`, or Node's `worker_threads` one
+ *
+ * @beta
+ */
+export interface NavigationWorkerLike {
+    postMessage(message: unknown, transfer?: unknown[]): void;
+    addEventListener?(type: 'message' | 'error', listener: (event: {
+        data?: unknown;
+        message?: string;
+    }) => void): void;
+    on?(type: 'message' | 'error', listener: (value: unknown) => void): void;
+}
+/**
+ * A builder that builds in a worker: one whose file serves builds (`serveNavigationBuilds`). In a page, the page makes
+ * the worker, as its bundler wants it: the library makes no worker of its own there.
+ *
+ * A worker's file of two lines (`serveNavigationBuilds` imported from the engine, and called), and the page:
+ * `navigationWorker(() => new Worker(new URL('./navigation.worker.ts', import.meta.url), { type: 'module' }))`, the
+ * builder of every world it makes (`NavigationBuilds`).
+ * Given as a function, the worker is made at the first build: a page whose menu builds nothing fetches none of it
+ * until a world is made (OF2); given made, it is used as it is
+ *
+ * @beta
+ */
+export declare function navigationWorker(given: NavigationWorkerLike | (() => NavigationWorkerLike)): NavigationBuilder;
+/**
+ * Where a worker hears and answers: a page's worker scope, or Node's `parentPort`
+ *
+ * @beta
+ */
+export interface NavigationPort {
+    postMessage(message: unknown, transfer?: unknown[]): void;
+    addEventListener?(type: 'message', listener: (event: {
+        data: unknown;
+    }) => void): void;
+    on?(type: 'message', listener: (value: unknown) => void): void;
+}
+/**
+ * What a navigation worker's file does: it builds what it is sent and sends back what it built. `port` is where it
+ * hears: the worker's own scope when left out (a page's worker)
+ *
+ * @beta
+ */
+export declare function serveNavigationBuilds(port?: NavigationPort): void;
+/**
+ * Who builds a world's navigations and where what was built is kept (`CreateWorldOptions.navigation.builds`): this
+ * thread when the builder is left out (a worker of the page's own: `navigationWorker`), the process's memory when the
+ * cache is, `cache: null` for nowhere (every world built anew). What an app hands every world it makes (`launch`,
+ * `startApp`, `GameServer.start`)
+ *
+ * @beta
+ */
+export interface NavigationBuilds {
+    builder?: NavigationBuilder;
+    cache?: NavigationCache | null;
+}
+/**
+ * What was built from this: kept, or built now (by the builder set) and kept. A builder that fails falls back to this
+ * thread once, and says why in what it throws only when that fails too
+ */
+export declare function navigationData(build: NavigationBuild, using?: NavigationBuilds): Promise<Uint8Array>;

package/dist/navigation/groundAreas.d.ts

@@ -0,0 +1,23 @@
+import { NavMesh, type QueryFilter, TileCache, TileCacheMeshProcess } from '@recast-navigation/core';
+import type { NavigationBuild, NavigationSpeeds } from './builds';
+/** The area of ground of this speed: 0 for ordinary ground, else its speed in sixteenths, 1 at the least and 62 at the most */
+export declare function areaOfSpeed(speed: number): number;
+/** What a path pays for each area of slow ground, on a filter: `1 / speed`, ordinary ground 1 */
+export declare function setAreaCosts(filter: QueryFilter): void;
+/** The speed of a cell of a build's grid: 1 off it, or with no grid */
+export declare function speedOfBuild(speeds: NavigationSpeeds | undefined, x: number, z: number): number;
+/**
+ * What makes a tile's polygons, as Recast's tile cache asks: each walkable (flags 1), its area the speed of the ground
+ * under its middle (`speedAt`). Without one, every polygon is ordinary ground, as Recast's default makes them
+ */
+export declare function groundMeshProcess(speedAt?: (x: number, z: number) => number): TileCacheMeshProcess;
+/**
+ * Builds a tile cache and its navmesh from a build, as Recast's `generateTileCache` does, but with each triangle of the
+ * ground marked with its cell's speed (`NavigationBuild.speeds`) before it is rasterised. What it gives is Recast's own;
+ * the caller exports and lets go of it
+ */
+export declare function generateGroundTileCache(build: NavigationBuild): {
+    navMesh: NavMesh;
+    tileCache: TileCache;
+    process: TileCacheMeshProcess;
+};

package/dist/navigation/navigation.d.ts

@@ -0,0 +1,127 @@
+import type { Rect, Vec2 } from '#engine/math';
+export interface AgentParams {
+    radius: number;
+    speed: number;
+    /** Moves through the air, where only other flyers are in the way */
+    flying?: boolean;
+    /** Goes on deep water only, where only other boats are in the way */
+    naval?: boolean;
+}
+export interface AgentState {
+    x: number;
+    z: number;
+    vx: number;
+    vz: number;
+    /** Next corner of the path, where the agent is heading right now. The destination itself when nothing is in the way */
+    cx: number;
+    cz: number;
+    /** The corner after that, where it heads next: the destination itself when the next corner is the last, or there is none */
+    nx: number;
+    nz: number;
+}
+/**
+ * An agent as it is right now, for a save: where it is, how fast it goes, where to, and how it behaves
+ *
+ * @beta
+ */
+export interface AgentSave {
+    x: number;
+    z: number;
+    vx: number;
+    vz: number;
+    radius: number;
+    speed: number;
+    /** How fast it gets up to speed, where that is not what follows from the speed */
+    acceleration?: number;
+    flying?: boolean;
+    naval?: boolean;
+    /** Where it was sent, snapped to where it can go. Null when it was not */
+    target: Vec2 | null;
+    anchored: boolean;
+    /** Where an anchored agent holds its ground */
+    anchor?: Vec2;
+    ghost: boolean;
+}
+/** @beta */
+export interface NavDebugGeometry {
+    /** xyz triples, 3 vertices per triangle */
+    triangles: Float32Array;
+    /** xyz triples, 2 vertices per line */
+    lines: Float32Array;
+}
+/**
+ * Pathfinding and local avoidance. The simulation only talks to this interface,
+ * so the backing implementation can be replaced without touching game logic.
+ *
+ * @beta
+ */
+export interface Navigation {
+    /** Bumped whenever walkable space changes (obstacles added or removed) */
+    readonly version: number;
+    addAgent(id: number, position: Vec2, params: AgentParams): void;
+    removeAgent(id: number): void;
+    hasAgent(id: number): boolean;
+    /** Path towards `target`. The target is snapped to walkable space; returns false when nothing walkable is near it. */
+    setDestination(id: number, target: Vec2): boolean;
+    clearDestination(id: number): void;
+    teleport(id: number, position: Vec2): void;
+    /** Anchored agents hold their ground: others have to walk around them instead of shoving them away. */
+    setAnchored(id: number, anchored: boolean): void;
+    /** Ghost agents ignore other agents (used by workers hauling resources). */
+    setGhost(id: number, ghost: boolean): void;
+    setSpeed(id: number, speed: number): void;
+    readAgent(id: number, out: AgentState): boolean;
+    /** What a save needs of an agent, or undefined when there is none of that id */
+    saveAgent(id: number): AgentSave | undefined;
+    /**
+     * Puts an agent back as it was saved. As close as it gets: the path it follows is looked for again,
+     * so what it does next can differ a little from what the agent that was saved would have done
+     */
+    restoreAgent(id: number, save: AgentSave): void;
+    /**
+     * Puts the agents back as loading a save puts them (determinism D2): those given and no others, in that order, each
+     * as `restoreAgent` puts it, on a crowd made anew. A save does this to the world it is taken of, so the game that
+     * was saved and the game loaded from it go on from the same crowd, to the last bit
+     */
+    reseat(agents: readonly (readonly [id: number, save: AgentSave])[]): void;
+    /** After a load: brings walkable space up to date with the obstacles put back, and takes on the version it had */
+    settle(version: number): void;
+    update(dt: number): void;
+    /**
+     * Something that blocks the way, a building or a shut gate. False when there is no room for another (see
+     * `obstacleRoom`): it is then not in the way, and never thrown over in the middle of a tick
+     */
+    addObstacle(key: number, rect: Rect): boolean;
+    removeObstacle(key: number): void;
+    /** How many more obstacles there is room for: what placing a building is refused over, before it is placed */
+    obstacleRoom(): number;
+    /**
+     * Many obstacles are put down at once, as a load puts back every structure: while held (true), what they change of
+     * walkable space waits, and is made once (each piece of ground once, however many obstacles are on it) when let go
+     * (false) or at the first thing asked of the navigation before that. What comes out is the same as putting them
+     * down one by one; only the work is less. Nothing where a navigation has nothing to hold
+     */
+    holdObstacles?(hold: boolean): void;
+    /**
+     * Whether two agents are in each other's way: on the same crowd, so that each steers around the other and neither
+     * walks through. Agents of different layers (ground, air, water), or of different sizes where the ground is cut for
+     * several (`SizedNavigation`), are not. Taken as yes where a navigation does not say
+     */
+    sameCrowd?(a: number, b: number): boolean;
+    /** Closest walkable point, or null when there is none within `searchRadius`. */
+    closestPoint(point: Vec2, searchRadius?: number): Vec2 | null;
+    findPath(from: Vec2, to: Vec2): Vec2[] | null;
+    /**
+     * A layer of cells that slows one on foot changed on these cells (`World.setCells`): what a path weighs there is
+     * made again (EN2). Nothing where a navigation weighs no ground
+     */
+    groundChanged?(cells: readonly number[]): void;
+    /**
+     * The ground it is a navigation of was reshaped (`World.reshapeGround`): cut again from it as it is now, at once, what
+     * is in the way and every agent kept as they were. False where it was not (a navigation of no ground, or one that
+     * cannot be cut of the ground as it is now): it is left as it was
+     */
+    reshape?(): boolean;
+    debugGeometry(): NavDebugGeometry;
+    dispose(): void;
+}

package/dist/navigation/recast.d.ts

@@ -0,0 +1,214 @@
+import { type NavigationBuilds } from './builds';
+import type { Rect, Vec2 } from '#engine/math';
+import type { Terrain } from '#engine/terrain';
+import type { AgentParams, AgentSave, AgentState, NavDebugGeometry, Navigation } from './navigation';
+/** @beta */
+export interface RecastNavigationOptions {
+    /** Who builds it and where what was built is kept: this thread and the process's memory when left out */
+    builds?: NavigationBuilds;
+    /** Navmesh is eroded by this radius, so it has to cover the largest unit */
+    agentRadius?: number;
+    /** Steepest slope units can walk, in degrees */
+    maxSlope?: number;
+    /**
+     * How many agents the crowd makes room for at first: 512 when left out. It is not a limit: a crowd that is full makes
+     * room for twice as many, and the agents go on as they were. A game that knows it brings thousands says so, to save
+     * those moves
+     */
+    maxAgents?: number;
+    /**
+     * How many obstacles (buildings, shut gates) there is room for: past it, placing one is refused. From the map's
+     * size when left out: half its cells, at least 8192, at most 65535
+     */
+    maxObstacles?: number;
+    /**
+     * How many steps a path search takes before it gives up with the best it found: a long path on a large map needs
+     * more. From the map's size when left out: a quarter of its cells, at least 4096, at most 65535
+     */
+    maxNodes?: number;
+    /**
+     * Navigations cut for units of these sizes, each unit on the one for the biggest size it is not smaller than: a
+     * big unit keeps from walls as far as it needs, where all keep 0.5 when left out. Each size is a navigation of its
+     * own, with its own crowd: units of different sizes walk through each other rather than around (see
+     * `SizedNavigation`)
+     */
+    radii?: number[];
+    cellSize?: number;
+    /**
+     * What it is a navigation of: the ground, walked on, or the deep water, sailed on (`Terrain.buildWaterMesh`), at
+     * the height of its surface. The ground when left out
+     */
+    surface?: 'ground' | 'water';
+    /**
+     * How agents steer around each other (Detour's obstacle avoidance): a level (`AVOIDANCE_LEVELS`: how carefully a
+     * crowd samples the velocities it might go at, `'medium'` being Detour's own), or the parts of `AvoidanceParams`
+     * to change, Detour's own for the rest. `'medium'` when left out. `'low'` crosses and gathers crowds as well
+     * in the measured cases for about a quarter less of a tick with a thousand walking, but it plays out other games
+     * differently (six of the example's tuned AI tests), so it is a game's choice
+     *
+     * @beta
+     */
+    avoidance?: AvoidanceLevel | Partial<AvoidanceParams>;
+    /**
+     * How hard agents push each other apart as they walk near each other (within eight radii), 0 for not at all:
+     * Detour's separation weight. 0.5 when left out: at Detour's 1.5, a unit walking past standing ones is pushed off
+     * its line and loses a tenth of its speed to it
+     */
+    separation?: number;
+    /**
+     * How fast one on foot goes over the ground at a point, as a multiplier (`groundSpeedOfCell`): what a path weighs,
+     * so that a way around slow ground wins where it is quicker (EN2). Asked as the ground is cut, and again for the tiles
+     * a slowing layer changed on (`groundChanged`). Every cell 1 when left out; never asked of the water
+     */
+    speedAt?: (x: number, z: number) => number;
+}
+/**
+ * How agents steer around each other: Detour's obstacle avoidance parameters, which weigh the velocities an agent
+ * samples each tick. The one that costs least wins: going the speed it wants (`weightDesVel`), going as it went
+ * (`weightCurVel`), passing on its preferred side (`weightSide`), and how soon it would hit something
+ * (`weightToi`, within `horizTime` seconds). `velBias` is how far the samples stray from the velocity it wants, 0..1
+ *
+ * @beta
+ */
+export interface AvoidanceParams {
+    velBias: number;
+    weightDesVel: number;
+    weightCurVel: number;
+    weightSide: number;
+    weightToi: number;
+    horizTime: number;
+    /** Samples a side in the grid sampling, odd. Only the adaptive sampling is used by the engine, which goes by the three below */
+    gridSize: number;
+    adaptiveDivs: number;
+    adaptiveRings: number;
+    adaptiveDepth: number;
+}
+/**
+ * How carefully a crowd steers: `'low'` samples fewer velocities, a cost a tick that grows with the crowd, `'high'` more
+ *
+ * @beta
+ */
+export type AvoidanceLevel = 'low' | 'medium' | 'high';
+/**
+ * What each `AvoidanceLevel` changes of `DEFAULT_AVOIDANCE`: the sampling (`adaptiveDivs`, `adaptiveRings` and
+ * `adaptiveDepth`, which what an agent costs a tick goes by)
+ *
+ * @beta
+ */
+export declare const AVOIDANCE_LEVELS: Readonly<Record<AvoidanceLevel, Readonly<Partial<AvoidanceParams>>>>;
+export declare class RecastNavigation implements Navigation {
+    private readonly terrain;
+    private navMesh;
+    private tileCache;
+    private crowd;
+    private query;
+    private readonly agentRadius;
+    /** How many agents the crowd has room for now: twice as many each time it is full */
+    private maxAgents;
+    /** How many obstacles the tile cache was made with room for */
+    private readonly maxObstacles;
+    /** How many steps a path search takes at most */
+    private readonly maxNodes;
+    /** What Recast's import made besides the navmesh and the tile cache, which the tile cache uses as long as it lives */
+    private owned;
+    /** How its agents steer around each other, and how hard they push apart (`RecastNavigationOptions`) */
+    readonly avoidance: Readonly<AvoidanceParams>;
+    readonly separation: number;
+    /** Where its tiles are: to make again those a slowing layer changed on, and to know which an obstacle touches */
+    private tiles;
+    /** The height of what it is a navigation of, at a point: the ground, or the water's surface */
+    private readonly heightAt;
+    /** What a path weighs (`speedAt`) */
+    private readonly ground?;
+    /** What it is cut from, the ground as it is now, the way it was first cut: to cut it again (`reshape`) */
+    private readonly cut?;
+    version: number;
+    private agents;
+    private obstacles;
+    /** The room the crowd was first made with: a crowd made anew (`reseat`) starts there, as a loaded world's does */
+    private firstMaxAgents;
+    private obstaclesDirty;
+    /** Obstacles are put down many at once (`holdObstacles`): their requests wait in the tile cache to be made into tiles together */
+    private holding;
+    /** Requests waiting while held, and the columns of the tile grid they touch (x * 65536 + z) */
+    private held;
+    private readonly heldColumns;
+    private readonly scratch;
+    private constructor();
+    static create(terrain: Terrain, options?: RecastNavigationOptions): Promise<RecastNavigation>;
+    /**
+     * The ground it is a navigation of was reshaped (`World.reshapeGround`): cut again from the ground as it is now, at
+     * once and on this thread, as it was cut first (its options, its slow ground); what is in the way put down again where
+     * it was, in the order it was, and every agent moved over as it stood, as a crowd that grows is. Every machine cuts it
+     * the same. False, and the navigation left as it was, where the ground as it is now cannot be cut (no water left)
+     */
+    reshape(): boolean;
+    /**
+     * A slowing layer of cells changed on these cells (`World.setCells`): the tiles they are on are made again, each
+     * polygon's area the speed under it now. As fine as the polygons the ground was cut into: a patch painted in play in
+     * the middle of one counts where the polygon's middle is
+     */
+    groundChanged(cells: readonly number[]): void;
+    /** The limits it was made with, from the map's size or the options: obstacles, and the steps of a path search */
+    get limits(): {
+        maxObstacles: number;
+        maxNodes: number;
+    };
+    /** How many agents the crowd has room for before it has to make more */
+    get capacity(): number;
+    /**
+     * Makes room for twice as many agents. A crowd (Detour's) is made for a number of agents and cannot grow, so a new
+     * one is made and every agent moved over as it is: where it is, how fast it goes, where to
+     */
+    private grow;
+    private toVec3;
+    addAgent(id: number, position: Vec2, params: AgentParams): void;
+    removeAgent(id: number): void;
+    hasAgent(id: number): boolean;
+    setDestination(id: number, target: Vec2): boolean;
+    clearDestination(id: number): void;
+    teleport(id: number, position: Vec2): void;
+    setAnchored(id: number, anchored: boolean): void;
+    /** Lets an anchored agent go: walking again, from where it stood. Detour checks the ground under it on its next step */
+    private wake;
+    setGhost(id: number, ghost: boolean): void;
+    setSpeed(id: number, speed: number): void;
+    saveAgent(id: number): AgentSave | undefined;
+    reseat(agents: readonly (readonly [id: number, save: AgentSave])[]): void;
+    restoreAgent(id: number, save: AgentSave): void;
+    settle(version: number): void;
+    readAgent(id: number, out: AgentState): boolean;
+    update(dt: number): void;
+    addObstacle(key: number, rect: Rect): boolean;
+    /**
+     * Holds obstacles back (true) or lets them go (false): while held, a request to put one down or take one up waits in
+     * the tile cache, and they are made into tiles together when let go or at the first thing asked of the navigation
+     * before that, each tile once however many obstacles are on it. The same tiles come of it as of making them one by
+     * one: a wooded tile is made once, not once a tree (RV42). The version goes up for each obstacle all the same
+     */
+    holdObstacles(hold: boolean): void;
+    /**
+     * Makes room for one more held request, of an obstacle at (x, z) of these half sizes: the ones held are made into
+     * tiles first when the tile cache would take no more of them (Detour queues 64), or when their tiles together would
+     * be more than it makes again from one batch (64, past which it leaves the rest as they were)
+     */
+    private makeRoom;
+    /**
+     * The columns of the tile grid an obstacle touches, or more: Detour takes a box obstacle's bounds as a square 1.41 times
+     * its longer half side about its middle, here 1.5 times, so that rounding never leaves one out
+     */
+    private columnsOf;
+    /** Every held request made into tiles: the tile cache up to date */
+    private drain;
+    obstacleRoom(): number;
+    removeObstacle(key: number): void;
+    /**
+     * The tile cache only queues a limited number of requests, so process them as they come: but while they are held
+     * (`holdObstacles`), when they wait to be made into tiles together
+     */
+    private flushObstacles;
+    closestPoint(point: Vec2, searchRadius?: number): Vec2 | null;
+    findPath(from: Vec2, to: Vec2): Vec2[] | null;
+    debugGeometry(): NavDebugGeometry;
+    dispose(): void;
+}

package/dist/navigation/sidePaths.d.ts

@@ -0,0 +1,69 @@
+import type { Entity } from '#engine/entity';
+import type { Rect, Vec2 } from '#engine/math';
+import type { System } from '#engine/registry';
+import type { Terrain } from '#engine/terrain';
+import type { World } from '#engine/world';
+import { type RecastNavigationOptions } from './recast';
+/**
+ * A building a side learned of by sight, where it saw it: its id and its rectangle
+ *
+ * @beta
+ */
+export type KnownBuilding = [id: number, x: number, z: number, hw: number, hd: number];
+/**
+ * The navigations of the sides, to plan routes on
+ *
+ * @beta
+ */
+export declare class SidePaths {
+    private readonly sides;
+    private stop?;
+    private constructor();
+    /** A navigation for each team, of the terrain alone, cut for `options` (the world's smallest unit) */
+    static create(terrain: Terrain, teams: readonly number[], options?: RecastNavigationOptions): Promise<SidePaths>;
+    /**
+     * Listens to the world for what every side knows as it happens: the map's, and each side's own and its allies'
+     * buildings, put down and gone. Given what the world has now, in its order, first: what a load starts from
+     */
+    attach(world: World): void;
+    /** Whether a team knows a building of `owner`'s without seeing it: the map's, its own, its allies' */
+    private always;
+    /** A building put down: what every side knows of it at once */
+    private put;
+    /** A building gone: forgotten at once where it was known without being seen */
+    private gone;
+    /** Whether a team plans with what it knows */
+    has(team: number): boolean;
+    /** One more each time what a team knows changes */
+    version(team: number): number;
+    knows(team: number, id: number): boolean;
+    /** The buildings a team knows, by id */
+    known(team: number): ReadonlyMap<number, Rect>;
+    /** A team knows a building from now: it is in the way of its routes. `seen` for one it learned of by sight */
+    learn(team: number, id: number, rect: Rect, seen?: boolean): void;
+    /** A team knows a building is gone */
+    forget(team: number, id: number): void;
+    /** Brings each navigation up to date with what was learned and forgotten: before a route is planned on it */
+    settle(): void;
+    /** The corners of a route from one point to another, as the team knows the ground. Null where it knows no way */
+    route(team: number, from: Vec2, to: Vec2): Vec2[] | null;
+    /** What the world keeps of it (`sideKnowledge`): what each side learned by sight */
+    save(): Record<number, KnownBuilding[]>;
+    /** After a load: what every side knows of the world as it is (`attach`), then what each learned by sight */
+    restore(world: World, saved: Record<number, KnownBuilding[]>): void;
+    /** Every enemy building of `team`'s, in the order they were put there: the ones it can come to know by sight */
+    strangers(world: World, team: number): Generator<Entity>;
+    /** The buildings a team learned of by sight */
+    seen(team: number): ReadonlyMap<number, Rect>;
+    /** A slowing layer of cells changed on these cells: each side's navigation weighs them again, as the world's does (EN2) */
+    groundChanged(cells: readonly number[]): void;
+    /** The ground was reshaped: each side's navigation cut again of it, as the world's is */
+    reshape(): void;
+    dispose(): void;
+}
+/**
+ * What each side learns by sight, after the fog is lit (`GameModule.paths: 'seen'`): another side's buildings once a
+ * cell of one is in sight, and that one gone once its place is. What it knows without seeing is the world's to tell
+ * as it happens (`SidePaths.attach`). Kept in the world (`sideKnowledge`) as it changes
+ */
+export declare const sideKnowledgeSystem: System;

package/dist/navigation/sized.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/navigation-worker.js

@@ -0,0 +1,11 @@
+import { c as serveNavigationBuilds } from "./builds-C6LfgvEU.js";
+import { parentPort } from "node:worker_threads";
+//#region src/server/navigation-worker.ts
+/**
+* A worker thread of a server's that builds navigations (S37): told what to build, it sends back what it built. Built
+* next to `server.js`, and not one of the engine's names: `nodeNavigationBuilder` starts it
+*/
+if (parentPort) serveNavigationBuilds(parentPort);
+//#endregion
+
+//# sourceMappingURL=navigation-worker.js.map

package/dist/navigation-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation-worker.js","names":[],"sources":["../src/server/navigation-worker.ts"],"sourcesContent":["/**\n * A worker thread of a server's that builds navigations (S37): told what to build, it sends back what it built. Built\n * next to `server.js`, and not one of the engine's names: `nodeNavigationBuilder` starts it\n */\nimport { parentPort } from 'node:worker_threads'\nimport { serveNavigationBuilds } from '#engine/navigation/builds'\n\nif (parentPort) serveNavigationBuilds(parentPort as never)\n"],"mappings":";;;;;;;AAOA,IAAI,YAAY,sBAAsB,UAAmB"}

package/dist/nearest.d.ts

@@ -0,0 +1,8 @@
+/** The id of a set closest to one that is not in it, when one is close enough to have been meant: what a check says was meant */
+export declare function nearestId(id: string, known: Iterable<string>): string | undefined;
+/**
+ * How many letters have to be changed, added or taken away to make one word of another: what says which id was meant
+ *
+ * @beta
+ */
+export declare function editDistance(a: string, b: string): number;

package/dist/noise.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Noise between 0 and 1 at a point, `u` and `v` 0..1 across the picture it repeats over
+ *
+ * @beta
+ */
+export type Noise2 = (u: number, v: number) => number;
+/**
+ * Several noises, each finer and fainter than the one before: what looks like ground and not like a pattern. 0..1
+ *
+ * @beta
+ */
+export declare function layeredNoise(seed: number, periods: readonly number[]): Noise2;