@daneren2005/shared-memory-physics 1.7.3 → 1.9.0

package/README.md

@@ -7,7 +7,7 @@ reads positions straight off its entities.
 
 Examples at https://daneren2005.github.io/shared-memory-physics/
 
-The ECS (`>=1.1.1`) and the shared-memory primitives it is built on are **peer dependencies**: a game must
+The ECS (`>=1.10.0`) and the shared-memory primitives it is built on are **peer dependencies**: a game must
 register these components against the same copy of the ECS it builds its world with.
 
 ```sh
@@ -23,6 +23,7 @@ npm install @daneren2005/shared-memory-physics @daneren2005/shared-memory-ecs @d
 | `velocity`      | –                                            | `velocityX?`, `velocityY?`, `damping?` | `Float32Array` – world units per second        |
 | `body`          | `shape?`, `collideCategory?`, `collideMask?`, `sensor?`, `continuousCollisionDetection?`, `blocksPath?` | –                          | `Uint32Array` – what shape, what collides with |
 | `interpolation` | `interpolate`                                | –                          | `Float32Array` – where to *draw* it            |
+| `navigation`    | `navigate`                                   | –                          | `Int32Array` – a goal and the path to it ([Pathfinding](#pathfinding)) |
 
 Entity configs are flat and shared across every component, so velocity is keyed as `velocityX` / `velocityY`
 rather than `x` / `y` (which already belong to the transform). Either velocity axis on its own is enough to
@@ -844,6 +845,21 @@ box around their actual outline. A direct transform/body edit outside the physic
 `world.updateSpatialEntity(entity)`. A custom physics wrapper that changes a transform after calling the library
 update can call `updateSpatialMap(workerWorld, entityId, components)` instead.
 
+For absolute placement from a worker update or an in-process update, `setEntityPosition` writes both coordinates
+and refreshes the shared index immediately on the calling thread:
+
+```ts
+import { setEntityPosition } from '@daneren2005/shared-memory-physics';
+
+setEntityPosition(workerWorld, { entityId, components }, { x: 300, y: 400 });
+```
+
+It accepts raw query/update blocks, ignores entities without a transform, and uses the optional body for
+shape-aware bounds. Each coordinate is stored atomically; the position and index update are not one transaction.
+It performs no collision sweep and does not change velocity or interpolation. For an interpolated teleport,
+reset the render state separately with `snapEntity` on the entity wrapper. Without a spatial map in the run
+world, it only writes the transform. Share the map with custom workers as described below.
+
 Games with registered ECS wrapper classes can pass their entity union as `PhysicalWorld`'s second generic. The
 world's entity map, lifecycle callbacks, and spatial-query results then retain that union instead of widening to
 `BaseEntity`.
@@ -895,9 +911,111 @@ ask it directly rather than building the sort yourself - it settles as soon as t
 measured to an entity's **box**, not to its centre, so a large target is as near as its nearest edge and
 `maxDistance` reads as a range past the hull.
 
+## Pathfinding
+
+Grid pathfinding for movers that need to walk around walls and buildings: an A* over tiles, run on a worker,
+answering requests written into a `navigation` component. Bodies flagged `blocksPath` are the walls. The physics
+still does the moving; the game reads the path back and steers velocity along it.
+
+Register `navigationRegistry` beside `physicsRegistry`, and give movers a `navigate: true` tag:
+
+```ts
+import { navigationRegistry, physicsRegistry, PathfindingSystem } from '@daneren2005/shared-memory-physics';
+
+const world = new PhysicalWorld({ ...physicsRegistry, ...navigationRegistry, ...gameRegistry });
+world.addSystem(new PathfindingSystem(world, {
+	getInitData: () => ({ tilesWide: 128, tilesHigh: 128, cellSize: 32 }),
+	getWorker: () => new Worker(new URL('./pathfinding.worker.ts', import.meta.url), { type: 'module' }),
+}));
+
+world.loadEntity({ x: 48, y: 48, width: 32, height: 32, blocksPath: true });       // a wall
+const villager = world.loadEntity({ x: 16, y: 16, width: 24, height: 24, navigate: true });
+villager.components.navigation!.navigateTo(400, 300);
+```
+
+The grid's `(0, 0)` is the world's top-left corner and anything off it is blocked. A worker file is the same two
+lines as physics', handing `createEntitySystemWorker` the update the system was given (`pathfindingUpdate` by default).
+
+### The navigation block
+
+Everything is in the mover's `navigation` block (an `Int32Array`), so any thread can set a goal or read a path:
+
+| Call | Does |
+| --- | --- |
+| `navigateTo(block, x, y)` | Sets the goal, marks the mover active and asks for a path |
+| `setNavigationGoal(block, x, y)` | Moves the goal without searching again; the last leg bends to it |
+| `requestPath(block)` | Searches again for the current goal |
+| `stopNavigating(block)` | Marks the mover inactive, so it is neither searched for nor rechecked |
+| `isPathPending(block)` / `isUnreachable(block)` | Whether an answer is still coming / settled as no way there |
+| `followPath(block, x, y, arriveDistance, target)` | Follower bookkeeping, below |
+
+A request is pending while its request id is ahead of its result id; the update writes waypoints and outcome
+first and the result id last, so a settled path is never read half written. Up to `NAVIGATION_MAX_WAYPOINTS` (32)
+waypoints fit; a longer path is cut short and marked `PathStatus.Incomplete`. Goals and paths are transient: whoever
+set a goal sets it again after a load.
+
+`followPath` is what a movement system calls each step. It skips waypoints within `arriveDistance`, writes the next
+point to head for into `target` (no allocation) and says what kind it is:
+
+```ts
+const step = followPath(navigation, x, y, 1, target);
+if(step === FollowStep.Waypoint || step === FollowStep.Goal) {
+	steerToward(target);
+} else {
+	halt(); // Waiting for a path, or Stuck at the closest reachable spot
+}
+```
+
+At the end of an incomplete path it asks for the rest itself and reports `Waiting`.
+
+### What the update does
+
+- Only **active** movers with a pending request are searched. Searching is budgeted per run in A* tiles
+  (`iterationBudget`, default `DEFAULT_PATH_SEARCH_ITERATION_BUDGET`), not wall-clock time, so a run plays out the
+  same on any machine; the first search of a run always goes ahead and the rest wait for the next run. The
+  budget is fixed when the update is built, but `PathfindingSystem`'s `iterationBudget` (a config option and a live
+  field) overrides it from the next run on - say, a larger one when the system is on a worker, where searching
+  costs no frame time. In-process, every tile of budget is main-thread time inside `world.update`.
+- Blockers are assumed never to move. Each is rasterised into the grid when it joins the `pathBlockers` query and
+  cleared when it leaves, and a new one re-paths only movers whose remaining path it crosses.
+- A mover standing inside a blocker (a bed built around a sleeper) searches as if that blocker were not there, so it
+  walks out rather than being relocated past a wall.
+- Paths are smoothed (string pulled) where the straight line is clear and no slower. A mover is placed by its
+  footprint, so one bigger than a tile only fits gaps its whole box fits.
+
+### Configuring it
+
+`createPathfindingUpdate` builds the update both backends run. Hooks are baked in because functions do not
+survive `postMessage`:
+
+```ts
+export const pathfindingUpdate = createPathfindingUpdate<Components, PathfindingUpdateComponents, GameWorld>({
+	search: new GridAStar({ diagonal: true }),
+	// Bodies in these categories stop only movers whose collide mask takes them in, e.g. doors animals cannot open.
+	gateCategories: DOOR,
+	init(navigation, data, queries) {
+		// Feed terrain in: 1.5 for a road, 0.5 for mud.
+		setNavigationTerrainSpeed(navigation, 3, 4, 1.5);
+	},
+	queryChanged(world, queryName, delta) { /* the game's extra queries */ },
+	preRun(world) { /* per-run upkeep */ },
+});
+```
+
+Pass it to `PathfindingSystem` as `updateFunction`, along with `blockers: { not: ['construction'] }` (or a `filter`)
+to narrow what counts as a blocker, `queries` for the hooks' own data, and `optional` for extra mover components.
+Another system wanting the same view of the world (say, finding enclosed pens) can build matching queries with
+`pathBlockerQueries` and keep its own `NavGrid` with `applyRectChanges`.
+
+Gates get a grid per set of gate categories a mover's mask takes in, cloned from the blockers grid the first time
+such a mover searches, so gates nobody collides with cost nothing.
+
+The search itself is swappable: anything implementing `PathSearch` (`findPath(grid, request)`) can be passed as
+`search`. `NavGrid`, `GridAStar`, `sweepCost` and `smoothPath` are exported for use on their own too.
+
 ## Examples
 
-Three runnable examples live in [`examples/`](./examples), rendered with [Phaser](https://phaser.io) (a dev
+Runnable examples live in [`examples/`](./examples), rendered with [Phaser](https://phaser.io) (a dev
 dependency - it is not part of the library) and driven by plain HTML controls beside the canvas:
 
 ```sh
@@ -912,6 +1030,11 @@ npm start          # http://127.0.0.1:8080
   them in turn. It starts on a deliberately long 100ms physics step, so turning **interpolate rendering** off is
   a direct before-and-after on the same running scene: the same simulation, drawn six frames at a time instead
   of one.
+- **Pathfinding** - click to send a square through a scene built to show each pathfinding case: a U-shaped trap,
+  a gap only small movers fit, mud and road terrain, round and angled blockers, and a door only some movers can
+  open. Toggle diagonal movement and smoothing, resize the mover, and add walls or paint terrain while it walks.
+- **Pathfinding stress** - thousands of movers wandering between random goals through hundreds of obstacles, with
+  obstacle churn re-pathing whoever a new wall crosses, and per-worker timings in the stats panel.
 
 Every page has a **physics step** slider (starting at the library's own 50ms) and an **interpolate rendering**
 toggle, so the trade the [interpolation section](#interpolation) describes can be looked at rather than

package/dist/actions/add-physical-world-data.d.ts

@@ -0,0 +1,2 @@
+import type { PhysicalWorldSource, PhysicalWorldData } from '../world';
+export declare function addPhysicalWorldData(source: PhysicalWorldSource, target: PhysicalWorldData): void;

package/dist/actions/combine-dynamics-commands.d.ts

@@ -0,0 +1,2 @@
+import type { DynamicsCommand, DynamicsCommands } from './dynamics-commands';
+export declare function combineDynamicsCommands(queued: ReadonlyMap<number, Omit<DynamicsCommand, 'entityId'>>, incoming: DynamicsCommands | undefined): DynamicsCommands | undefined;

package/dist/{systems/dynamics.d.ts → actions/dynamics-commands.d.ts}

@@ -34,10 +34,4 @@ export interface DynamicsWorld {
     elapsedTime: number;
     dynamicsCommands?: DynamicsCommands;
 }
-export declare function queueDynamicsVector(commands: PendingDynamicsCommands, entityId: number, forceX: number, forceY: number, impulseX: number, impulseY: number): void;
-export declare function queueVelocityAssignment(commands: PendingDynamicsCommands, entityId: number, velocity: VelocityAssignment): void;
-export declare function combineDynamicsCommands(queued: ReadonlyMap<number, Omit<DynamicsCommand, 'entityId'>>, incoming: DynamicsCommands | undefined): DynamicsCommands | undefined;
-export declare function integrateDynamics(world: DynamicsWorld, entityId: number, velocity: Float32Array, dynamics?: Float32Array): void;
-export declare function findDynamicsCommand(commands: ReadonlyArray<DynamicsCommand> | undefined, entityId: number): DynamicsCommand | undefined;
-export declare function findDynamicsCommandOffset(commands: DynamicsCommandBuffer, entityId: number): number;
-export default integrateDynamics;
+export declare function emptyCommand(): Omit<DynamicsCommand, 'entityId'>;

package/dist/actions/find-dynamics-command-offset.d.ts

@@ -0,0 +1,2 @@
+import type { DynamicsCommandBuffer } from './dynamics-commands';
+export declare function findDynamicsCommandOffset(commands: DynamicsCommandBuffer, entityId: number): number;

package/dist/actions/find-dynamics-command.d.ts

@@ -0,0 +1,2 @@
+import type { DynamicsCommand } from './dynamics-commands';
+export declare function findDynamicsCommand(commands: ReadonlyArray<DynamicsCommand> | undefined, entityId: number): DynamicsCommand | undefined;

package/dist/actions/get-spatial-map.d.ts

@@ -0,0 +1,3 @@
+import SharedSpatialMap from '@daneren2005/shared-memory-objects/spatial/shared-spatial-map';
+import type { PhysicalSystemWorld } from '../world';
+export declare function getSpatialMap(world: PhysicalSystemWorld): SharedSpatialMap;

package/dist/actions/integrate-dynamics.d.ts

@@ -0,0 +1,3 @@
+import type { DynamicsWorld } from './dynamics-commands';
+export declare function integrateDynamics(world: DynamicsWorld, entityId: number, velocity: Float32Array, dynamics?: Float32Array): void;
+export default integrateDynamics;

package/dist/actions/queue-dynamics-vector.d.ts

@@ -0,0 +1,2 @@
+import type { PendingDynamicsCommands } from './dynamics-commands';
+export declare function queueDynamicsVector(commands: PendingDynamicsCommands, entityId: number, forceX: number, forceY: number, impulseX: number, impulseY: number): void;

package/dist/actions/queue-velocity-assignment.d.ts

@@ -0,0 +1,2 @@
+import type { PendingDynamicsCommands, VelocityAssignment } from './dynamics-commands';
+export declare function queueVelocityAssignment(commands: PendingDynamicsCommands, entityId: number, velocity: VelocityAssignment): void;

package/dist/actions/set-entity-position.d.ts

@@ -0,0 +1,7 @@
+import type { EntityUpdateComponents } from '@daneren2005/shared-memory-ecs/worker';
+import type { Vector } from '../math/shapes';
+import type { PhysicalSystemWorld } from '../world';
+export declare function setEntityPosition(world: PhysicalSystemWorld, entity: {
+    entityId: number;
+    components: EntityUpdateComponents;
+}, position: Vector): void;

package/dist/actions/snap-entity.d.ts

@@ -0,0 +1,9 @@
+import type { TransformComponent } from '../components/transform-component';
+import type { InterpolationComponent } from '../components/interpolation-component';
+export interface SnappableEntity {
+    components: {
+        transform?: TransformComponent;
+        interpolation?: InterpolationComponent;
+    };
+}
+export declare function snapEntity(entity: SnappableEntity): void;

package/dist/actions/start-spawn-interpolation.d.ts

@@ -0,0 +1,16 @@
+import type { TransformComponent } from '../components/transform-component';
+import type { VelocityComponent } from '../components/velocity-component';
+import type { InterpolationComponent } from '../components/interpolation-component';
+export interface SpawnableEntity {
+    components: {
+        transform?: TransformComponent;
+        velocity?: VelocityComponent;
+        interpolation?: InterpolationComponent;
+    };
+}
+export interface SpawnInterpolationOptions {
+    stepMs: number;
+    stepFraction: number;
+    tick: number;
+}
+export declare function startSpawnInterpolation(entity: SpawnableEntity, options: SpawnInterpolationOptions): void;

package/dist/actions/update-spatial-map.d.ts

@@ -0,0 +1,3 @@
+import { type SpatialBlockComponents } from '../systems/spatial-bounds';
+import type { PhysicalSystemWorld } from '../world';
+export declare function updateSpatialMap(world: PhysicalSystemWorld, entityId: number, components: SpatialBlockComponents): void;

package/dist/components/body-component-constants.d.ts

@@ -0,0 +1,15 @@
+export declare const SHAPE_RECTANGLE = 1;
+export declare const SHAPE_CIRCLE = 2;
+export declare const SHAPE_CAPSULE = 3;
+export declare const SHAPE_POLYGON = 4;
+export declare const DEFAULT_COLLIDE_CATEGORY = 1;
+export declare const DEFAULT_COLLIDE_MASK = 4294967295;
+export declare const BODY_FLAGS_INDEX = 0;
+export declare const BODY_CATEGORY_INDEX = 1;
+export declare const BODY_MASK_INDEX = 2;
+export declare const BODY_SIZE = 3;
+export declare const BODY_SHAPE_MASK = 7;
+export declare const BODY_SENSOR_FLAG = 8;
+export declare const BODY_CCD_FLAG = 16;
+export declare const BODY_DYING_FLAG = 32;
+export declare const BODY_BLOCKS_PATH_FLAG = 64;

package/dist/components/body-component.d.ts

@@ -9,12 +9,6 @@ export interface BodyComponent {
     continuousCollisionDetection: boolean;
     blocksPath: boolean;
 }
-export declare const SHAPE_RECTANGLE = 1;
-export declare const SHAPE_CIRCLE = 2;
-export declare const SHAPE_CAPSULE = 3;
-export declare const SHAPE_POLYGON = 4;
-export declare const DEFAULT_COLLIDE_CATEGORY = 1;
-export declare const DEFAULT_COLLIDE_MASK = 4294967295;
 export declare function canCollide(categoryA: number, maskA: number, categoryB: number, maskB: number): boolean;
 export interface BodyConfig {
     width?: number;
@@ -28,15 +22,6 @@ export interface BodyConfig {
     continuousCollisionDetection?: boolean;
     blocksPath?: boolean;
 }
-export declare const BODY_FLAGS_INDEX = 0;
-export declare const BODY_CATEGORY_INDEX = 1;
-export declare const BODY_MASK_INDEX = 2;
-export declare const BODY_SIZE = 3;
-export declare const BODY_SHAPE_MASK = 7;
-export declare const BODY_SENSOR_FLAG = 8;
-export declare const BODY_CCD_FLAG = 16;
-export declare const BODY_DYING_FLAG = 32;
-export declare const BODY_BLOCKS_PATH_FLAG = 64;
 export declare function bodyShape(body: Uint32Array): number;
 export declare function isSensor(body: Uint32Array): boolean;
 export declare function isContinuous(body: Uint32Array): boolean;

package/dist/components/bounciness-component-constants.d.ts

@@ -0,0 +1,2 @@
+export declare const BOUNCINESS_INDEX = 0;
+export declare const BOUNCINESS_SIZE = 1;

package/dist/components/bounciness-component.d.ts

@@ -6,7 +6,5 @@ export interface BouncinessComponent {
 export interface BouncinessConfig {
     bounciness?: number;
 }
-export declare const BOUNCINESS_INDEX = 0;
-export declare const BOUNCINESS_SIZE = 1;
 export declare const bouncinessDefinition: ComponentDefinition<BouncinessComponent, Float32Array, BouncinessConfig>;
 export default bouncinessDefinition;

package/dist/components/dynamics-component-constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DYNAMICS_ACCELERATION_X_INDEX = 0;
+export declare const DYNAMICS_ACCELERATION_Y_INDEX = 1;
+export declare const DYNAMICS_INVERSE_MASS_INDEX = 2;
+export declare const DYNAMICS_SIZE = 3;

package/dist/components/dynamics-component.d.ts

@@ -11,9 +11,5 @@ export interface DynamicsConfig {
     mass?: number;
 }
 export type DynamicsSerialization = DynamicsConfig;
-export declare const DYNAMICS_ACCELERATION_X_INDEX = 0;
-export declare const DYNAMICS_ACCELERATION_Y_INDEX = 1;
-export declare const DYNAMICS_INVERSE_MASS_INDEX = 2;
-export declare const DYNAMICS_SIZE = 3;
 export declare const dynamicsDefinition: ComponentDefinition<DynamicsComponent, Float32Array, DynamicsConfig, DynamicsSerialization>;
 export default dynamicsDefinition;

package/dist/components/interpolation-component-constants.d.ts

@@ -0,0 +1,18 @@
+export declare const INTERPOLATION_X_INDEX = 0;
+export declare const INTERPOLATION_Y_INDEX = 1;
+export declare const INTERPOLATION_SYNCED_TICK_INDEX = 2;
+export declare const INTERPOLATION_DURATION_INDEX = 3;
+export declare const INTERPOLATION_TICK_INDEX = 4;
+export declare const INTERPOLATION_TOTAL_DURATION_INDEX = 5;
+export declare const INTERPOLATION_SYNCED_DURATION_INDEX = 6;
+export declare const INTERPOLATION_REMAINING_DURATION_INDEX = 7;
+export declare const INTERPOLATION_TARGET_X_INDEX = 8;
+export declare const INTERPOLATION_TARGET_Y_INDEX = 9;
+export declare const INTERPOLATION_SYNCED_STEP_DURATION_INDEX = 10;
+export declare const INTERPOLATION_CHANNEL_INDEX = 11;
+export declare const INTERPOLATION_PREVIOUS_X_INDEX = 12;
+export declare const INTERPOLATION_PREVIOUS_Y_INDEX = 13;
+export declare const INTERPOLATION_PREVIOUS_DURATION_INDEX = 14;
+export declare const INTERPOLATION_PREVIOUS_TOTAL_DURATION_INDEX = 15;
+export declare const INTERPOLATION_PREVIOUS_TICK_INDEX = 16;
+export declare const INTERPOLATION_SIZE = 17;

package/dist/components/interpolation-component.d.ts

@@ -1,6 +1,4 @@
 import type { ComponentDefinition } from '@daneren2005/shared-memory-ecs';
-import type { TransformComponent } from './transform-component';
-import type { VelocityComponent } from './velocity-component';
 export interface InterpolationComponent {
     index: number;
     x: number;
@@ -22,43 +20,5 @@ export interface InterpolationConfig {
     x?: number;
     y?: number;
 }
-export declare const INTERPOLATION_X_INDEX = 0;
-export declare const INTERPOLATION_Y_INDEX = 1;
-export declare const INTERPOLATION_SYNCED_TICK_INDEX = 2;
-export declare const INTERPOLATION_DURATION_INDEX = 3;
-export declare const INTERPOLATION_TICK_INDEX = 4;
-export declare const INTERPOLATION_TOTAL_DURATION_INDEX = 5;
-export declare const INTERPOLATION_SYNCED_DURATION_INDEX = 6;
-export declare const INTERPOLATION_REMAINING_DURATION_INDEX = 7;
-export declare const INTERPOLATION_TARGET_X_INDEX = 8;
-export declare const INTERPOLATION_TARGET_Y_INDEX = 9;
-export declare const INTERPOLATION_SYNCED_STEP_DURATION_INDEX = 10;
-export declare const INTERPOLATION_CHANNEL_INDEX = 11;
-export declare const INTERPOLATION_PREVIOUS_X_INDEX = 12;
-export declare const INTERPOLATION_PREVIOUS_Y_INDEX = 13;
-export declare const INTERPOLATION_PREVIOUS_DURATION_INDEX = 14;
-export declare const INTERPOLATION_PREVIOUS_TOTAL_DURATION_INDEX = 15;
-export declare const INTERPOLATION_PREVIOUS_TICK_INDEX = 16;
-export declare const INTERPOLATION_SIZE = 17;
 export declare const interpolationDefinition: ComponentDefinition<InterpolationComponent, Float32Array, InterpolationConfig>;
-export interface SnappableEntity {
-    components: {
-        transform?: TransformComponent;
-        interpolation?: InterpolationComponent;
-    };
-}
-export declare function snapEntity(entity: SnappableEntity): void;
-export interface SpawnableEntity {
-    components: {
-        transform?: TransformComponent;
-        velocity?: VelocityComponent;
-        interpolation?: InterpolationComponent;
-    };
-}
-export interface SpawnInterpolationOptions {
-    stepMs: number;
-    stepFraction: number;
-    tick: number;
-}
-export declare function startSpawnInterpolation(entity: SpawnableEntity, options: SpawnInterpolationOptions): void;
 export default interpolationDefinition;

package/dist/components/navigation-component-constants.d.ts

@@ -0,0 +1,11 @@
+export declare const NAVIGATION_REQUEST_INDEX = 0;
+export declare const NAVIGATION_RESULT_INDEX = 1;
+export declare const NAVIGATION_OUTCOME_INDEX = 2;
+export declare const NAVIGATION_WAYPOINT_INDEX = 3;
+export declare const NAVIGATION_WAYPOINT_COUNT_INDEX = 4;
+export declare const NAVIGATION_ACTIVE_INDEX = 5;
+export declare const NAVIGATION_GOAL_X_INDEX = 6;
+export declare const NAVIGATION_GOAL_Y_INDEX = 7;
+export declare const NAVIGATION_WAYPOINTS_INDEX = 8;
+export declare const NAVIGATION_MAX_WAYPOINTS = 32;
+export declare const NAVIGATION_SIZE: number;

package/dist/components/navigation-component.d.ts

@@ -0,0 +1,31 @@
+import type { ComponentDefinition } from '@daneren2005/shared-memory-ecs';
+import { type Point } from '../pathfinding/path-search';
+export interface NavigationComponent {
+    index: number;
+    readonly active: boolean;
+    readonly goalX: number;
+    readonly goalY: number;
+    readonly pending: boolean;
+    readonly outcome: number;
+    readonly waypointIndex: number;
+    readonly waypoints: Array<Point>;
+    navigateTo(x: number, y: number): void;
+    stop(): void;
+}
+export interface NavigationConfig {
+    navigate: boolean;
+}
+export declare const navigationDefinition: ComponentDefinition<NavigationComponent, Int32Array, NavigationConfig>;
+export declare function navigateTo(navigation: Int32Array, x: number, y: number): void;
+export declare function setNavigationGoal(navigation: Int32Array, x: number, y: number): void;
+export declare function stopNavigating(navigation: Int32Array): void;
+export declare function isNavigating(navigation: Int32Array): boolean;
+export declare function requestPath(navigation: Int32Array): void;
+export declare function isPathPending(navigation: Int32Array): boolean;
+export declare function isUnreachable(navigation: Int32Array): boolean;
+export declare function navigationGoal(navigation: Int32Array): Point;
+export declare function waypoint(navigation: Int32Array, i: number): Point;
+export declare function waypointX(navigation: Int32Array, i: number): number;
+export declare function waypointY(navigation: Int32Array, i: number): number;
+export declare function writePath(navigation: Int32Array, status: number, points: ReadonlyArray<Point>): void;
+export default navigationDefinition;

package/dist/components/polygon-component-constants.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_POLYGON_VERTICES = 16;
+export declare const POLYGON_VERTEX_COUNT_INDEX = 0;
+export declare const POLYGON_VERTICES_INDEX = 1;
+export declare const POLYGON_SIZE: number;

package/dist/components/polygon-component.d.ts

@@ -10,10 +10,6 @@ export interface PolygonComponent {
     readonly block: Float32Array;
     readonly vertexCount: number;
 }
-export declare const MAX_POLYGON_VERTICES = 16;
-export declare const POLYGON_VERTEX_COUNT_INDEX = 0;
-export declare const POLYGON_VERTICES_INDEX = 1;
-export declare const POLYGON_SIZE: number;
 export interface PreparedPolygon {
     width: number;
     height: number;

package/dist/components/registry.d.ts

@@ -2,6 +2,7 @@ import { type BodyComponent } from './body-component';
 import { type BouncinessComponent } from './bounciness-component';
 import { type DynamicsComponent } from './dynamics-component';
 import { type InterpolationComponent } from './interpolation-component';
+import { type NavigationComponent } from './navigation-component';
 import { type PolygonComponent } from './polygon-component';
 import { type TransformComponent } from './transform-component';
 import { type VelocityComponent } from './velocity-component';
@@ -14,6 +15,9 @@ export declare const physicsRegistry: {
     dynamics: import("@daneren2005/shared-memory-ecs").ComponentDefinition<DynamicsComponent, Float32Array<ArrayBufferLike>, import("./dynamics-component").DynamicsConfig, import("./dynamics-component").DynamicsConfig>;
     interpolation: import("@daneren2005/shared-memory-ecs").ComponentDefinition<InterpolationComponent, Float32Array<ArrayBufferLike>, import("./interpolation-component").InterpolationConfig, object>;
 };
+export declare const navigationRegistry: {
+    navigation: import("@daneren2005/shared-memory-ecs").ComponentDefinition<NavigationComponent, Int32Array<ArrayBufferLike>, import("./navigation-component").NavigationConfig, object>;
+};
 export type PhysicsComponents = {
     transform: TransformComponent;
     velocity: VelocityComponent;
@@ -27,6 +31,11 @@ export type InterpolationComponents = {
     transform: TransformComponent;
     interpolation: InterpolationComponent;
 };
+export type NavigationComponents = {
+    navigation: NavigationComponent;
+    transform: TransformComponent;
+    body: BodyComponent;
+};
 export type PhysicsUpdateComponents = {
     transform: Float32Array;
     velocity: Float32Array;

package/dist/components/transform-component-constants.d.ts

@@ -0,0 +1,6 @@
+export declare const TRANSFORM_X_INDEX = 0;
+export declare const TRANSFORM_Y_INDEX = 1;
+export declare const TRANSFORM_WIDTH_INDEX = 2;
+export declare const TRANSFORM_HEIGHT_INDEX = 3;
+export declare const TRANSFORM_ANGLE_INDEX = 4;
+export declare const TRANSFORM_SIZE = 5;

package/dist/components/transform-component.d.ts

@@ -20,11 +20,5 @@ export interface TransformSerialization {
     y: number;
     angle?: number;
 }
-export declare const TRANSFORM_X_INDEX = 0;
-export declare const TRANSFORM_Y_INDEX = 1;
-export declare const TRANSFORM_WIDTH_INDEX = 2;
-export declare const TRANSFORM_HEIGHT_INDEX = 3;
-export declare const TRANSFORM_ANGLE_INDEX = 4;
-export declare const TRANSFORM_SIZE = 5;
 export declare const transformDefinition: ComponentDefinition<TransformComponent, Float32Array, TransformConfig, TransformSerialization>;
 export default transformDefinition;

package/dist/components/velocity-component-constants.d.ts

@@ -0,0 +1,4 @@
+export declare const VELOCITY_X_INDEX = 0;
+export declare const VELOCITY_Y_INDEX = 1;
+export declare const VELOCITY_DAMPING_INDEX = 2;
+export declare const VELOCITY_SIZE = 3;

package/dist/components/velocity-component.d.ts

@@ -11,9 +11,5 @@ export interface VelocityConfig {
     damping?: number;
 }
 export type VelocitySerialization = VelocityConfig;
-export declare const VELOCITY_X_INDEX = 0;
-export declare const VELOCITY_Y_INDEX = 1;
-export declare const VELOCITY_DAMPING_INDEX = 2;
-export declare const VELOCITY_SIZE = 3;
 export declare const velocityDefinition: ComponentDefinition<VelocityComponent, Float32Array, VelocityConfig, VelocitySerialization>;
 export default velocityDefinition;

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const POSITION_UPDATED_EVENT = "position-updated";
+export declare const COLLIDABLE_QUERY = "collidable";
+export declare const DEFAULT_PHYSICS_STEP_MS = 50;
+export declare const BACKLOG_TARGET_STEPS = 1.5;
+export declare const BACKLOG_CATCHUP_RATE = 0.5;