screeps-clockwork 0.4.0 → 0.5.0

package/dist/src/wrappers/dijkstraFlowField.d.ts

@@ -1,4 +1,8 @@
 import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
+import { ClockworkFlowField } from './flowField';
+import { ClockworkMonoFlowField } from './monoFlowField';
+import { ClockworkMultiroomFlowField } from './multiroomFlowField';
+import { ClockworkMultiroomMonoFlowField } from './multiroomMonoFlowField';
 /**
  * Generate a [flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
  * using Dijkstra's algorithm.
@@ -12,7 +16,7 @@ import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
  * @param costMatrix - The cost matrix to use for the flow field.
  * @returns The flow field.
  */
-export declare function dijkstraFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").FlowField;
+export declare function dijkstraFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): ClockworkFlowField;
 /**
  * Generate a [mono-directional flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html)
  * for a set of positions using Dijkstra's algorithm.
@@ -29,4 +33,44 @@ export declare function dijkstraFlowField(start: RoomPosition[], costMatrix: Clo
  * @param costMatrix - The cost matrix to use for the flow field.
  * @returns The flow field.
  */
-export declare function dijkstraMonoFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").MonoFlowField;
+export declare function dijkstraMonoFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): ClockworkMonoFlowField;
+/**
+ * Generate a multiroom flow field for a set of positions using Dijkstra's algorithm.
+ *
+ * Dijkstra's algorithm includes variable costs to account for terrain or other cost functions.
+ *
+ * Note that values of 0 in the cost matrix may have unexpected behavior. You probably want
+ * a cost matrix with a default value of at least 1.
+ *
+ * @param start - The starting positions.
+ * @param costMatrixCallback - A function that returns a cost matrix for a given room name.
+ * @param options - Options for the flow field generation.
+ * @returns The flow field.
+ */
+export declare function dijkstraMultiroomFlowField(start: RoomPosition[], { costMatrixCallback, maxTiles, maxRooms, maxRoomDistance, maxTileDistance }: {
+    costMatrixCallback: (roomName: string) => ClockworkCostMatrix | undefined;
+    maxTiles?: number;
+    maxRooms?: number;
+    maxRoomDistance?: number;
+    maxTileDistance?: number;
+}): ClockworkMultiroomFlowField;
+/**
+ * Generate a multiroom mono-directional flow field for a set of positions using Dijkstra's algorithm.
+ *
+ * Dijkstra's algorithm includes variable costs to account for terrain or other cost functions.
+ *
+ * Note that values of 0 in the cost matrix may have unexpected behavior. You probably want
+ * a cost matrix with a default value of at least 1.
+ *
+ * @param start - The starting positions.
+ * @param costMatrixCallback - A function that returns a cost matrix for a given room name.
+ * @param options - Options for the flow field generation.
+ * @returns The flow field.
+ */
+export declare function dijkstraMultiroomMonoFlowField(start: RoomPosition[], { costMatrixCallback, maxTiles, maxRooms, maxRoomDistance, maxTileDistance }: {
+    costMatrixCallback: (roomName: string) => ClockworkCostMatrix | undefined;
+    maxTiles?: number;
+    maxRooms?: number;
+    maxRoomDistance?: number;
+    maxTileDistance?: number;
+}): ClockworkMultiroomMonoFlowField;

package/dist/src/wrappers/distanceMap.d.ts

@@ -0,0 +1,29 @@
+import { DistanceMap } from '../wasm/screeps_clockwork';
+import { Path } from './path';
+/**
+ * A distance map for a single room.
+ */
+export declare class ClockworkDistanceMap {
+    private _map;
+    constructor(_map: DistanceMap);
+    /**
+     * Gets the distance value at a given position.
+     */
+    get(x: number, y: number): number;
+    /**
+     * Sets the distance value at a given position.
+     */
+    set(x: number, y: number, value: number): void;
+    /**
+     * Converts the distance map into a flat array of distances.
+     */
+    toArray(): Uint32Array;
+    /**
+     * Frees the memory allocated for this distance map.
+     */
+    free(): void;
+    /**
+     * Path to the origin from a given position.
+     */
+    pathToOrigin(start: RoomPosition): Path;
+}

package/dist/src/wrappers/flowField.d.ts

@@ -0,0 +1,38 @@
+import { FlowField } from '../wasm/screeps_clockwork';
+import { Path } from './path';
+/**
+ * A flow field for a single room that stores multiple directions per tile.
+ */
+export declare class ClockworkFlowField {
+    private _flowField;
+    constructor(_flowField: FlowField);
+    /**
+     * Get the internal value for a given coordinate.
+     */
+    get(x: number, y: number): number;
+    /**
+     * Set the internal value for a given coordinate.
+     */
+    set(x: number, y: number, value: number): void;
+    /**
+     * Get the list of valid directions for a given coordinate.
+     */
+    getDirections(x: number, y: number): DirectionConstant[];
+    /**
+     * Set the list of valid directions for a given coordinate.
+     */
+    setDirections(x: number, y: number, directions: DirectionConstant[]): void;
+    /**
+     * Add a direction to the list of valid directions for a given coordinate.
+     */
+    addDirection(x: number, y: number, direction: DirectionConstant): void;
+    /**
+     * Free the memory allocated for this flow field.
+     */
+    free(): void;
+    /**
+     * Given a flow field (for a single room), find the path from a given position to
+     * the origin. Never paths through other rooms.
+     */
+    pathToOrigin(start: RoomPosition): Path;
+}

package/dist/src/wrappers/monoFlowField.d.ts

@@ -0,0 +1,26 @@
+import { MonoFlowField } from '../wasm/screeps_clockwork';
+import { Path } from './path';
+/**
+ * A flow field for a single room that stores one direction per tile.
+ */
+export declare class ClockworkMonoFlowField {
+    private _flowField;
+    constructor(_flowField: MonoFlowField);
+    /**
+     * Get the direction for a given coordinate.
+     */
+    get(x: number, y: number): DirectionConstant | undefined;
+    /**
+     * Set the direction for a given coordinate.
+     */
+    set(x: number, y: number, value?: DirectionConstant): void;
+    /**
+     * Free the memory allocated for this flow field.
+     */
+    free(): void;
+    /**
+     * Given a monodirectional flow field (for a single room), find the path from a given position to
+     * the origin. Never paths through other rooms.
+     */
+    pathToOrigin(start: RoomPosition): Path;
+}

package/dist/src/wrappers/multiroomDistanceMap.d.ts

@@ -0,0 +1,34 @@
+import { DistanceMap, MultiroomDistanceMap } from '../wasm/screeps_clockwork';
+import { Path } from './path';
+/**
+ * A distance map that covers multiple rooms. Typically returned by a function
+ * like `bfsMultiroomDistanceMap` rather than created directly.
+ */
+export declare class ClockworkMultiroomDistanceMap {
+    private _map;
+    constructor(_map: MultiroomDistanceMap);
+    /**
+     * Get the stored value for a given position.
+     */
+    get(pos: RoomPosition): number;
+    /**
+     * Set the stored value for a given position.
+     */
+    set(pos: RoomPosition, value: number): void;
+    /**
+     * Get the DistanceMap for a given room.
+     */
+    getRoom(room: string): DistanceMap | undefined;
+    /**
+     * List all the rooms covered by this distance map.
+     */
+    getRooms(): string[];
+    /**
+     * Free the memory allocated for this distance map.
+     */
+    free(): void;
+    /**
+     * Path to the origin from a given position.
+     */
+    pathToOrigin(start: RoomPosition): Path;
+}

package/dist/src/wrappers/multiroomFlowField.d.ts

@@ -0,0 +1,46 @@
+import { MultiroomFlowField } from '../wasm/screeps_clockwork';
+import { ClockworkFlowField } from './flowField';
+import { Path } from './path';
+/**
+ * A flow field that spans multiple rooms, storing multiple directions per tile.
+ */
+export declare class ClockworkMultiroomFlowField {
+    private _flowField;
+    constructor(_flowField: MultiroomFlowField);
+    /**
+     * Get the flow field value at a given position.
+     */
+    get(pos: RoomPosition): number;
+    /**
+     * Set the flow field value at a given position.
+     */
+    set(pos: RoomPosition, value: number): void;
+    /**
+     * Get the list of valid directions at a given position.
+     */
+    getDirections(pos: RoomPosition): DirectionConstant[];
+    /**
+     * Set the list of valid directions at a given position.
+     */
+    setDirections(pos: RoomPosition, directions: DirectionConstant[]): void;
+    /**
+     * Add a direction to the list of valid directions at a given position.
+     */
+    addDirection(pos: RoomPosition, direction: DirectionConstant): void;
+    /**
+     * Get the list of rooms in the flow field.
+     */
+    getRooms(): string[];
+    /**
+     * Get the flow field for a given room.
+     */
+    getRoom(roomName: string): ClockworkFlowField | null;
+    /**
+     * Find a path from a given position to the origin of the flow field.
+     */
+    pathToOrigin(start: RoomPosition): Path;
+    /**
+     * Free the memory allocated for this flow field.
+     */
+    free(): void;
+}

package/dist/src/wrappers/multiroomMonoFlowField.d.ts

@@ -0,0 +1,34 @@
+import { MultiroomMonoFlowField } from '../wasm/screeps_clockwork';
+import { ClockworkMonoFlowField } from './monoFlowField';
+import { Path } from './path';
+/**
+ * A flow field that spans multiple rooms, storing a single direction per tile.
+ */
+export declare class ClockworkMultiroomMonoFlowField {
+    private _flowField;
+    constructor(_flowField: MultiroomMonoFlowField);
+    /**
+     * Get the direction at a given position.
+     */
+    get(pos: RoomPosition): DirectionConstant | null;
+    /**
+     * Set the direction at a given position.
+     */
+    set(pos: RoomPosition, direction: DirectionConstant | null): void;
+    /**
+     * Get the list of rooms in the flow field.
+     */
+    getRooms(): string[];
+    /**
+     * Get the flow field for a given room.
+     */
+    getRoom(roomName: string): ClockworkMonoFlowField | null;
+    /**
+     * Find a path from a given position to the origin of the flow field.
+     */
+    pathToOrigin(start: RoomPosition): Path;
+    /**
+     * Free the memory allocated for this flow field.
+     */
+    free(): void;
+}

package/dist/src/wrappers/path.d.ts

@@ -1,7 +1,21 @@
 import { Path as ClockworkPath } from '../wasm/screeps_clockwork';
+/**
+ * A path from a start position to an end position. Typically returned by a
+ * function like `pathToFlowFieldOrigin` rather than created directly.
+ */
 export declare class Path {
     private readonly path;
     constructor(path: ClockworkPath);
+    /**
+     * Iterate over the path.
+     *
+     * @example
+     * ```typescript
+     * for (const pos of path) {
+     *   console.log(pos);
+     * }
+     * ```
+     */
     [Symbol.iterator](): {
         next: () => {
             value: RoomPosition;
@@ -9,7 +23,14 @@ export declare class Path {
         };
     };
     /**
-     * Iterate over the path in reverse order
+     * Iterate over the path in reverse order.
+     *
+     * @example
+     * ```typescript
+     * for (const pos of path.reversed()) {
+     *   console.log(pos);
+     * }
+     * ```
      */
     reversed(): Generator<never, {
         next: () => {
@@ -17,10 +38,28 @@ export declare class Path {
             done: boolean;
         };
     }, unknown>;
+    /**
+     * Get the position at a given index.
+     */
     get(index: number): RoomPosition;
+    /**
+     * Get the length of the path.
+     */
     get length(): number;
-    findNextIndex(index: number): number | undefined;
+    /**
+     * Given a current position, find the index of the next position in the path.
+     */
+    findNextIndex(pos: RoomPosition): number | undefined;
+    /**
+     * Convert the path to an array of positions.
+     */
     toArray(): RoomPosition[];
+    /**
+     * Convert the path to an array of positions in reverse order.
+     */
     toArrayReversed(): RoomPosition[];
+    /**
+     * Free the memory allocated for this path.
+     */
     free(): void;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "screeps-clockwork",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A WASM movement library for Screeps",
   "main": "dist/index.js",
   "types": "dist/src/index.d.ts",
@@ -36,19 +36,19 @@
     "@rollup/plugin-node-resolve": "^15.1.0",
     "@rollup/plugin-typescript": "^12.1.1",
     "@rollup/plugin-wasm": "^6.2.2",
-    "@types/node": "^22.9.3",
+    "@types/node": "^22.10.1",
     "@types/screeps": "^3.3.0",
-    "@typescript-eslint/eslint-plugin": "^8.15.0",
-    "@typescript-eslint/parser": "^8.15.0",
-    "eslint": "^9.15.0",
+    "@typescript-eslint/eslint-plugin": "^8.17.0",
+    "@typescript-eslint/parser": "^8.17.0",
+    "eslint": "^9.16.0",
     "npm-run-all": "^4.1.5",
-    "prettier": "^3.3.3",
+    "prettier": "^3.4.2",
     "rollup": "2.79.2",
     "rollup-plugin-clear": "^2.0.7",
     "rollup-plugin-copy": "^3.5.0",
     "rollup-plugin-screeps": "^1.0.1",
     "source-map": "0.6.1",
-    "typedoc": "^0.27.0-beta.2",
+    "typedoc": "^0.27.3",
     "typescript": "^5.7.2"
   },
   "dependencies": {

package/dist/src/wrappers/pathtoDistanceMapOrigin.d.ts

@@ -1,3 +0,0 @@
-import { DistanceMap } from '../wasm/screeps_clockwork';
-import { Path } from './path';
-export declare function pathToDistanceMapOrigin(start: RoomPosition, distanceMap: DistanceMap): Path;

package/dist/src/wrappers/pathtoFlowFieldOrigin.d.ts

@@ -1,3 +0,0 @@
-import { FlowField } from '../wasm/screeps_clockwork';
-import { Path } from './path';
-export declare function pathToFlowFieldOrigin(start: RoomPosition, flowField: FlowField): Path;

package/dist/src/wrappers/pathtoMonoFlowFieldOrigin.d.ts

@@ -1,3 +0,0 @@
-import { MonoFlowField } from '../wasm/screeps_clockwork';
-import { Path } from './path';
-export declare function pathToMonoFlowFieldOrigin(start: RoomPosition, flowField: MonoFlowField): Path;