@daneren2005/shared-memory-physics 1.8.0 → 1.9.0

package/dist/pathfinding/follow-path.d.ts

@@ -0,0 +1,9 @@
+import { type Point } from './path-search';
+export declare const FollowStep: {
+    readonly Waiting: 0;
+    readonly Waypoint: 1;
+    readonly Goal: 2;
+    readonly Stuck: 3;
+};
+export type FollowStepValue = typeof FollowStep[keyof typeof FollowStep];
+export declare function followPath(navigation: Int32Array, x: number, y: number, arriveDistance: number, target: Point): FollowStepValue;

package/dist/pathfinding/grid-a-star.d.ts

@@ -0,0 +1,29 @@
+import type NavGrid from './nav-grid';
+import { type PathRequest, type PathResult, type PathSearch } from './path-search';
+export interface GridAStarOptions {
+    diagonal?: boolean;
+    maxIterations?: number;
+    smooth?: boolean;
+    clearance?: number;
+    relocateRadius?: number;
+}
+export default class GridAStar implements PathSearch {
+    private readonly diagonal;
+    private readonly maxIterations;
+    private readonly smooth;
+    private readonly clearance;
+    private readonly relocateRadius;
+    private readonly heap;
+    private cost;
+    private parent;
+    private seen;
+    private closed;
+    private stamp;
+    constructor(options?: GridAStarOptions);
+    findPath(grid: NavGrid, request: PathRequest): PathResult;
+    private relocate;
+    private search;
+    private relax;
+    private trace;
+    private prepare;
+}

package/dist/pathfinding/line-of-sight.d.ts

@@ -0,0 +1,2 @@
+import type NavGrid from './nav-grid';
+export declare function sweepCost(grid: NavGrid, x0: number, y0: number, x1: number, y1: number, halfWidth: number, halfHeight: number): number;

package/dist/pathfinding/min-heap.d.ts

@@ -0,0 +1,14 @@
+export default class MinHeap {
+    private ids;
+    private primary;
+    private secondary;
+    private count;
+    constructor(capacity?: number);
+    get size(): number;
+    clear(): void;
+    push(id: number, primary: number, secondary?: number): void;
+    pop(): number;
+    private less;
+    private set;
+    private grow;
+}

package/dist/pathfinding/nav-grid.d.ts

@@ -0,0 +1,42 @@
+export interface Rect {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export interface TileRange {
+    fromX: number;
+    fromY: number;
+    toX: number;
+    toY: number;
+}
+export default class NavGrid {
+    readonly tilesWide: number;
+    readonly tilesHigh: number;
+    readonly cellSize: number;
+    private blockers;
+    private speeds;
+    private fastestSpeed;
+    private regions;
+    private regionsDirty;
+    constructor(tilesWide: number, tilesHigh: number, cellSize: number);
+    clone(): NavGrid;
+    get tileCount(): number;
+    get maxSpeed(): number;
+    inBounds(tileX: number, tileY: number): boolean;
+    index(tileX: number, tileY: number): number;
+    tileOf(world: number): number;
+    tileCenter(tile: number): number;
+    isBlocked(tileX: number, tileY: number): boolean;
+    isAreaClear(tileX: number, tileY: number, tilesWide: number, tilesHigh: number): boolean;
+    blockerCount(tileX: number, tileY: number): number;
+    tilesIn(rect: Rect): TileRange;
+    addBlocker(rect: Rect): void;
+    removeBlocker(rect: Rect): void;
+    setTerrainSpeed(tileX: number, tileY: number, speed: number): void;
+    terrainSpeed(tileX: number, tileY: number): number;
+    cost(tileX: number, tileY: number): number;
+    region(tileX: number, tileY: number): number;
+    private rebuildRegions;
+    private flood;
+}

package/dist/pathfinding/navigation-state.d.ts

@@ -0,0 +1,20 @@
+import NavGrid, { type Rect } from './nav-grid';
+import { type PathBlockerDelta } from './path-blockers';
+interface Gate {
+    rect: Rect;
+    category: number;
+}
+export interface NavigationState {
+    grid: NavGrid;
+    blockers: Map<number, Rect>;
+    gateCategories: number;
+    gates: Map<number, Gate>;
+    gatedGrids: Map<number, NavGrid>;
+}
+export declare function createNavigationState(tilesWide: number, tilesHigh: number, cellSize: number, gateCategories?: number): NavigationState;
+export declare function navigationGridFor(state: NavigationState, collideMask: number): NavGrid;
+export declare function blockingRects(state: NavigationState, collideMask: number): Array<Rect>;
+export declare function setNavigationTerrainSpeed(state: NavigationState, tileX: number, tileY: number, speed: number): void;
+export declare function applyPathBlockerChanges(state: NavigationState, delta: PathBlockerDelta): boolean;
+export declare function applyPathGateChanges(state: NavigationState, delta: PathBlockerDelta): boolean;
+export {};

package/dist/pathfinding/path-blockers.d.ts

@@ -0,0 +1,29 @@
+import type { BaseEntity, ComponentMap, EntityWorkerSystemQuery } from '@daneren2005/shared-memory-ecs';
+import type { BodyComponent } from '../components/body-component';
+import type { TransformComponent } from '../components/transform-component';
+import type NavGrid from './nav-grid';
+import type { Rect } from './nav-grid';
+export declare const PATH_BLOCKERS_QUERY = "pathBlockers";
+export declare const PATH_GATES_QUERY = "pathGates";
+export type PathBlockerComponents = {
+    transform: TransformComponent;
+    body: BodyComponent;
+};
+export interface PathBlockerDelta {
+    added: ReadonlyArray<{
+        entityId: number;
+        components: {
+            transform?: unknown;
+            body?: unknown;
+        };
+    }>;
+    removed: ReadonlyArray<number>;
+}
+export interface PathBlockerQueryOptions<C extends ComponentMap> {
+    gateCategories?: number;
+    not?: Array<keyof C>;
+    filter?: (entity: BaseEntity<C>) => boolean;
+}
+export declare function pathBlockerQueries<C extends ComponentMap & PathBlockerComponents>(options?: PathBlockerQueryOptions<C>): Record<string, EntityWorkerSystemQuery<C>>;
+export declare function blockerRect(transform: Float32Array, body: Uint32Array): Rect;
+export declare function applyRectChanges(rects: Map<number, Rect>, grids: Iterable<NavGrid>, delta: PathBlockerDelta): boolean;

package/dist/pathfinding/path-search.d.ts

@@ -0,0 +1,27 @@
+import type NavGrid from './nav-grid';
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface PathRequest {
+    startX: number;
+    startY: number;
+    goalX: number;
+    goalY: number;
+    agentWidth: number;
+    agentHeight: number;
+}
+export declare const PathStatus: {
+    readonly Found: 1;
+    readonly Incomplete: 2;
+    readonly Unreachable: 3;
+};
+export type PathStatusValue = typeof PathStatus[keyof typeof PathStatus];
+export interface PathResult {
+    status: PathStatusValue;
+    points: Array<Point>;
+    iterations: number;
+}
+export interface PathSearch {
+    findPath(grid: NavGrid, request: PathRequest): PathResult;
+}

package/dist/pathfinding/pathfinding-system.d.ts

@@ -0,0 +1,27 @@
+import { EntityWorkerSystem } from '@daneren2005/shared-memory-ecs';
+import type { BaseEntity, BaseWorld, ComponentDefinitionMap, ComponentMap, EntityUpdateComponents, EntityWorkerSystemQuery, SystemConfig } from '@daneren2005/shared-memory-ecs';
+import type { NavigationComponents } from '../components/registry';
+import { type PathfindingInitData, type PathfindingUpdateComponents, type PathfindingUpdateFunction, type PathfindingWorld } from './pathfinding-update';
+export interface PathfindingSystemConfig<C extends ComponentMap & NavigationComponents, T extends PathfindingUpdateComponents & EntityUpdateComponents<C>, W extends PathfindingWorld, D extends PathfindingInitData> extends Partial<SystemConfig> {
+    getInitData: () => D;
+    getWorker?: () => Worker;
+    forceMainThread?: boolean;
+    updateFunction?: PathfindingUpdateFunction<C, T, W, D>;
+    blockers?: {
+        not?: Array<keyof C>;
+        filter?: (entity: BaseEntity<C>) => boolean;
+    };
+    queries?: {
+        [key: string]: EntityWorkerSystemQuery<C>;
+    };
+    optional?: Array<keyof C & string>;
+    iterationBudget?: number;
+}
+export default class PathfindingSystem<C extends ComponentMap & NavigationComponents, T extends PathfindingUpdateComponents & EntityUpdateComponents<C> = PathfindingUpdateComponents & EntityUpdateComponents<C>, W extends PathfindingWorld = PathfindingWorld, D extends PathfindingInitData = PathfindingInitData> extends EntityWorkerSystem<C, T, W, D> {
+    iterationBudget: number | undefined;
+    constructor(world: BaseWorld<ComponentDefinitionMap, C>, options: PathfindingSystemConfig<C, T, W, D>);
+    addDataToWorld(world: W): void;
+    private loaded;
+    init(): Promise<void>;
+    finishLoading(): Promise<void>;
+}

package/dist/pathfinding/pathfinding-update.d.ts

@@ -0,0 +1,36 @@
+import type { ComponentMap, EntityQueryChangedFunction, EntityQueryComponents, EntityUpdateComponents, EntityUpdateFunction, EntityUpdatePreRunFunction, EntityWorkerSystemWorld } from '@daneren2005/shared-memory-ecs';
+import { type NavigationState } from './navigation-state';
+import { type PathSearch } from './path-search';
+export declare const DEFAULT_PATH_SEARCH_ITERATION_BUDGET = 16000;
+export type PathfindingUpdateComponents = {
+    navigation: Int32Array;
+    transform: Float32Array;
+    body?: Uint32Array;
+};
+export interface PathfindingInitData {
+    tilesWide: number;
+    tilesHigh: number;
+    cellSize: number;
+}
+export interface PathfindingWorld extends EntityWorkerSystemWorld {
+    navigation: NavigationState;
+    blockersAdded?: boolean;
+    searchIterations?: number;
+    iterationBudget?: number;
+}
+export interface PathfindingUpdateOptions<C extends ComponentMap, T extends PathfindingUpdateComponents & EntityUpdateComponents<C>, W extends PathfindingWorld, D extends PathfindingInitData> {
+    search?: PathSearch;
+    iterationBudget?: number;
+    gateCategories?: number;
+    init?: (navigation: NavigationState, data: D | undefined, queries: EntityQueryComponents<C>) => Partial<W> | void;
+    queryChanged?: EntityQueryChangedFunction<C, W>;
+    preRun?: EntityUpdatePreRunFunction<C, T, W>;
+}
+export interface PathfindingUpdateMetadata {
+    gateCategories: number;
+}
+export type PathfindingUpdateFunction<C extends ComponentMap, T extends PathfindingUpdateComponents & EntityUpdateComponents<C>, W extends PathfindingWorld, D extends PathfindingInitData> = EntityUpdateFunction<C, T, W, D> & {
+    pathfinding: PathfindingUpdateMetadata;
+};
+export declare function createPathfindingUpdate<C extends ComponentMap = ComponentMap, T extends PathfindingUpdateComponents & EntityUpdateComponents<C> = PathfindingUpdateComponents & EntityUpdateComponents<C>, W extends PathfindingWorld = PathfindingWorld, D extends PathfindingInitData = PathfindingInitData>(options?: PathfindingUpdateOptions<C, T, W, D>): PathfindingUpdateFunction<C, T, W, D>;
+export declare const pathfindingUpdate: PathfindingUpdateFunction<ComponentMap, PathfindingUpdateComponents & EntityUpdateComponents<ComponentMap>, PathfindingWorld, PathfindingInitData>;

package/dist/pathfinding/smooth-path.d.ts

@@ -0,0 +1,3 @@
+import type NavGrid from './nav-grid';
+import type { Point } from './path-search';
+export declare function smoothPath(grid: NavGrid, points: ReadonlyArray<Point>, halfWidth: number, halfHeight: number, clearance: number): Array<Point>;

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@daneren2005/shared-memory-physics",
 	"description": "2D physics components and systems built on the shared-memory ECS.",
 	"author": "Scott Jackson",
-	"version": "1.8.0",
+	"version": "1.9.0",
 	"type": "module",
 	"sideEffects": false,
 	"license": "MIT",
@@ -42,7 +42,7 @@
 		"prepare": "husky"
 	},
 	"devDependencies": {
-		"@daneren2005/shared-memory-ecs": "^1.8.1",
+		"@daneren2005/shared-memory-ecs": "^1.10.2",
 		"@daneren2005/shared-memory-objects": "^1.6.0",
 		"@semantic-release/git": "^10.0.1",
 		"@stylistic/eslint-plugin": "^5.10.0",
@@ -60,7 +60,7 @@
 		"vitest": "^5.0.1"
 	},
 	"peerDependencies": {
-		"@daneren2005/shared-memory-ecs": "^1.5.1",
+		"@daneren2005/shared-memory-ecs": "^1.10.0",
 		"@daneren2005/shared-memory-objects": "^1.1.0"
 	},
 	"dependencies": {