screeps-clockwork 0.4.0 → 0.5.0

package/dist/src/index.d.ts

@@ -5,11 +5,12 @@ export * from './wrappers/bfsDistanceMap';
 export * from './wrappers/bfsFlowField';
 export * from './wrappers/dijkstraDistanceMap';
 export * from './wrappers/dijkstraFlowField';
+export * from './wrappers/flowField';
 export * from './wrappers/getRange';
+export * from './wrappers/monoFlowField';
+export * from './wrappers/multiroomFlowField';
+export * from './wrappers/multiroomMonoFlowField';
 export * from './wrappers/path';
-export * from './wrappers/pathtoDistanceMapOrigin';
-export * from './wrappers/pathtoFlowFieldOrigin';
-export * from './wrappers/pathtoMonoFlowFieldOrigin';
 /**
  * The `initialize` function should be called in your main loop before
  * using any other screeps-clockwork functions. Depending on available

package/dist/src/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const MAX_USIZE = 4294967295;

package/dist/src/utils/fromPacked.d.ts

@@ -1 +1,3 @@
 export declare function fromPacked(packedPos: number): RoomPosition;
+export declare function fromPackedRoomName(packedRoomName: number): string;
+export declare function packRoomName(room: string): number;

package/dist/src/wasm/screeps_clockwork.d.ts

@@ -1,76 +1,55 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
- * WASM wrapper for the Dijkstra flow field function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {FlowField}
+ * WASM wrapper for the BFS multiroom flow field function.
  */
-export function js_dijkstra_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): FlowField;
-/**
- * @param {number} start
- * @param {MonoFlowField} flow_field
- * @returns {Path}
- */
-export function js_path_to_mono_flow_field_origin(start: number, flow_field: MonoFlowField): Path;
+export function js_bfs_multiroom_flow_field(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomFlowField;
 /**
  * WASM wrapper for the Dijkstra distance map function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {DistanceMap}
  */
 export function js_dijkstra_distance_map(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): DistanceMap;
+export function js_path_to_flow_field_origin(start: number, flow_field: FlowField): Path;
 /**
- * WASM wrapper for the BFS mono flow field function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {MonoFlowField}
+ * WASM wrapper for the BFS distance map function.
  */
-export function js_bfs_mono_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): MonoFlowField;
+export function js_bfs_distance_map(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): DistanceMap;
+export function js_dijkstra_multiroom_distance_map(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomDistanceMap;
+export function js_dijkstra_multiroom_flow_field(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomFlowField;
 /**
- * @param {number} start
- * @param {DistanceMap} distance_map
- * @returns {Path}
+ * WASM wrapper for the BFS multiroom distance map function.
  */
-export function js_path_to_distance_map_origin(start: number, distance_map: DistanceMap): Path;
+export function js_bfs_multiroom_distance_map(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomDistanceMap;
 /**
- * @returns {string}
+ * WASM wrapper for the Dijkstra flow field function.
  */
-export function version(): string;
+export function js_dijkstra_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): FlowField;
+export function js_dijkstra_multiroom_mono_flow_field(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomMonoFlowField;
+export function js_path_to_multiroom_distance_map_origin(start: number, distance_map: MultiroomDistanceMap): Path;
 /**
- * Exports the global range calculation between two positions.
- * @param {number} packed_pos_1
- * @param {number} packed_pos_2
- * @returns {number}
+ * WASM wrapper for the BFS flow field function.
  */
-export function get_range(packed_pos_1: number, packed_pos_2: number): number;
+export function js_bfs_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): FlowField;
+export function js_path_to_mono_flow_field_origin(start: number, flow_field: MonoFlowField): Path;
+export function js_path_to_multiroom_mono_flow_field_origin(start: number, flow_field: MultiroomMonoFlowField): Path;
 /**
- * WASM wrapper for the BFS distance map function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {DistanceMap}
+ * WASM wrapper for the BFS multiroom monodirectional flow field function.
  */
-export function js_bfs_distance_map(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): DistanceMap;
+export function js_bfs_multiroom_mono_flow_field(start_packed: Uint32Array, get_cost_matrix: Function, max_tiles: number, max_rooms: number, max_room_distance: number, max_tile_distance: number): MultiroomMonoFlowField;
 /**
- * WASM wrapper for the BFS flow field function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {FlowField}
+ * WASM wrapper for the BFS mono flow field function.
  */
-export function js_bfs_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): FlowField;
+export function js_bfs_mono_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): MonoFlowField;
+export function js_path_to_distance_map_origin(start: number, distance_map: DistanceMap): Path;
+export function js_path_to_multiroom_flow_field_origin(start: number, flow_field: MultiroomFlowField): Path;
 /**
  * WASM wrapper for the Dijkstra mono flow field function.
- * @param {Uint32Array} start_packed
- * @param {ClockworkCostMatrix} cost_matrix
- * @returns {MonoFlowField}
  */
 export function js_dijkstra_mono_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): MonoFlowField;
+export function version(): string;
 /**
- * @param {number} start
- * @param {FlowField} flow_field
- * @returns {Path}
+ * Exports the global range calculation between two positions.
  */
-export function js_path_to_flow_field_origin(start: number, flow_field: FlowField): Path;
+export function get_range(packed_pos_1: number, packed_pos_2: number): number;
 /**
  * Translates `COLOR_*` and `COLORS_ALL` constants.
  */
@@ -223,21 +202,14 @@ export class ClockworkCostMatrix {
   /**
    * Creates a new cost matrix within the WASM module. Optionally, a default value
    * can be provided to initialize all cells in the matrix to that value.
-   * @param {number | undefined} [_default]
    */
   constructor(_default?: number);
   /**
    * Gets the cost of a given position in the cost matrix.
-   * @param {number} x
-   * @param {number} y
-   * @returns {number}
    */
   get(x: number, y: number): number;
   /**
    * Sets the cost of a given position in the cost matrix.
-   * @param {number} x
-   * @param {number} y
-   * @param {number} value
    */
   set(x: number, y: number, value: number): void;
 }
@@ -245,24 +217,18 @@ export class ClockworkCostMatrix {
  * Maps a distance value onto individual room tile positions.
  */
 export class DistanceMap {
+  private constructor();
   free(): void;
   /**
    * Converts the distance map into a flat array of distances.
-   * @returns {Uint32Array}
    */
   toArray(): Uint32Array;
   /**
    * Gets the distance value at a given position.
-   * @param {number} x
-   * @param {number} y
-   * @returns {number}
    */
   get(x: number, y: number): number;
   /**
    * Sets the distance value at a given position.
-   * @param {number} x
-   * @param {number} y
-   * @param {number} value
    */
   set(x: number, y: number, value: number): void;
 }
@@ -273,40 +239,26 @@ export class DistanceMap {
  * 8-bit unsigned integer represents a direction that is either viable or not).
  */
 export class FlowField {
+  private constructor();
   free(): void;
   /**
    * Get the internal value for a given coordinate.
-   * @param {number} x
-   * @param {number} y
-   * @returns {number}
    */
   get(x: number, y: number): number;
   /**
    * Set the internal value for a given coordinate.
-   * @param {number} x
-   * @param {number} y
-   * @param {number} value
    */
   set(x: number, y: number, value: number): void;
   /**
    * Get the list of valid directions for a given coordinate.
-   * @param {number} x
-   * @param {number} y
-   * @returns {any[]}
    */
   getDirections(x: number, y: number): any[];
   /**
    * Set the list of valid directions for a given coordinate.
-   * @param {number} x
-   * @param {number} y
-   * @param {any[]} directions
    */
   setDirections(x: number, y: number, directions: any[]): void;
   /**
    * Add a direction to the list of valid directions for a given coordinate.
-   * @param {number} x
-   * @param {number} y
-   * @param {Direction} direction
    */
   addDirection(x: number, y: number, direction: Direction): void;
 }
@@ -317,56 +269,124 @@ export class FlowField {
  * integer (0 for no direction, 1 for TOP, etc.).
  */
 export class MonoFlowField {
+  private constructor();
   free(): void;
   /**
    * Get the direction for a given coordinate.
-   * @param {number} x
-   * @param {number} y
-   * @returns {Direction | undefined}
    */
   get(x: number, y: number): Direction | undefined;
   /**
    * Set the direction for a given coordinate.
-   * @param {number} x
-   * @param {number} y
-   * @param {Direction | undefined} [value]
    */
   set(x: number, y: number, value?: Direction): void;
 }
 /**
- * A list of positions representing a path.
+ * Maps distance values across multiple rooms, storing a DistanceMap for each room
  */
-export class Path {
+export class MultiroomDistanceMap {
   free(): void;
   /**
-   * @param {number} packed_position
+   * Creates a new empty multiroom distance map (JavaScript constructor)
    */
-  add(packed_position: number): void;
+  constructor();
   /**
-   * @param {number} index
-   * @returns {number | undefined}
+   * Gets the distance value at a given position
    */
-  get(index: number): number | undefined;
+  get(packed_pos: number): number;
+  /**
+   * Sets the distance value at a given position
+   */
+  set(packed_pos: number, value: number): void;
+  /**
+   * Gets the list of rooms in the map
+   */
+  get_rooms(): Uint16Array;
+  /**
+   * Gets the DistanceMap for a given room
+   */
+  get_room(room_name: number): DistanceMap | undefined;
+}
+/**
+ * Maps flow field values across multiple rooms, storing a FlowField for each room
+ */
+export class MultiroomFlowField {
+  free(): void;
+  /**
+   * Creates a new empty multiroom flow field (JavaScript constructor)
+   */
+  constructor();
+  /**
+   * Gets the flow field value at a given position
+   */
+  get(packed_pos: number): number;
+  /**
+   * Sets the flow field value at a given position
+   */
+  set(packed_pos: number, value: number): void;
+  /**
+   * Gets the list of rooms in the flow field
+   */
+  getRooms(): Uint16Array;
+  /**
+   * Gets the FlowField for a given room
+   */
+  getRoom(room_name: number): FlowField | undefined;
+  /**
+   * Gets the list of valid directions at a given position (JavaScript)
+   */
+  getDirections(packed_pos: number): any[];
+  /**
+   * Sets the list of valid directions at a given position (JavaScript)
+   */
+  setDirections(packed_pos: number, directions: any[]): void;
+  /**
+   * Adds a direction to the list of valid directions at a given position (JavaScript)
+   */
+  addDirection(packed_pos: number, direction: Direction): void;
+}
+/**
+ * Maps monodirectional flow field values across multiple rooms, storing a MonoFlowField for each room
+ */
+export class MultiroomMonoFlowField {
+  free(): void;
+  /**
+   * Creates a new empty multiroom monodirectional flow field (JavaScript constructor)
+   */
+  constructor();
   /**
-   * @returns {number}
+   * Gets the direction at a given position
    */
+  get(packed_pos: number): Direction | undefined;
+  /**
+   * Sets the direction at a given position
+   */
+  set(packed_pos: number, direction?: Direction): void;
+  /**
+   * Gets the list of rooms in the flow field
+   */
+  getRooms(): Uint16Array;
+  /**
+   * Gets the MonoFlowField for a given room
+   */
+  getRoom(room_name: number): MonoFlowField | undefined;
+}
+/**
+ * A list of positions representing a path.
+ */
+export class Path {
+  private constructor();
+  free(): void;
+  add(packed_position: number): void;
+  get(index: number): number | undefined;
   len(): number;
   /**
    * Given a position, find the index of the next adjacent position
    * in the path. If the position is not in the path, the target is
    * the next adjacent position closest to the end of the path. If
    * the position is neither on nor adjacent to the path, return None.
-   * @param {number} packed_position
-   * @returns {number | undefined}
    */
   find_next_index(packed_position: number): number | undefined;
-  /**
-   * @returns {Uint32Array}
-   */
   to_array(): Uint32Array;
-  /**
-   * @returns {Uint32Array}
-   */
   to_array_reversed(): Uint32Array;
 }
 /**
@@ -375,9 +395,6 @@ export class Path {
  */
 export class PathFatigue {
   free(): void;
-  /**
-   * @param {Path} path
-   */
   constructor(path: Path);
   /**
    * Refreshes fatigue cost for each position in the path. If the PathFatigue
@@ -386,24 +403,19 @@ export class PathFatigue {
    * list *has* been initialized, only positions with vision will be updated.
    *
    * When there is vision, this also accounts for roads at the position.
-   * @param {Path} path
    */
   refresh(path: Path): void;
-  /**
-   * @returns {number}
-   */
   len(): number;
   /**
    * Calculates the total move time for the path, given a fatigue ratio.
    *
    * For unboosted creeps, the ratio is `Math.floor(moveParts * 2 / fatigueParts)`
    * where `fatigue_parts` are any part except MOVE and empty CARRY parts.
-   * @param {number} fatigue_ratio
-   * @returns {number}
    */
   moveTime(fatigue_ratio: number): number;
 }
 export class SearchGoal {
+  private constructor();
   free(): void;
   readonly pos: any;
   readonly range: number;
@@ -413,53 +425,84 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly __wbg_path_free: (a: number, b: number) => void;
-  readonly __wbg_pathfatigue_free: (a: number, b: number) => void;
-  readonly path_add: (a: number, b: number) => void;
-  readonly path_get: (a: number, b: number, c: number) => void;
-  readonly path_len: (a: number) => number;
-  readonly path_find_next_index: (a: number, b: number, c: number) => void;
-  readonly path_to_array: (a: number, b: number) => void;
-  readonly path_to_array_reversed: (a: number, b: number) => void;
-  readonly pathfatigue_new: (a: number) => number;
-  readonly pathfatigue_refresh: (a: number, b: number) => void;
-  readonly pathfatigue_moveTime: (a: number, b: number) => number;
-  readonly pathfatigue_len: (a: number) => number;
-  readonly js_dijkstra_flow_field: (a: number, b: number, c: number) => number;
+  readonly js_bfs_multiroom_flow_field: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+  readonly js_dijkstra_distance_map: (a: number, b: number, c: number) => number;
+  readonly js_path_to_flow_field_origin: (a: number, b: number) => number;
   readonly __wbg_flowfield_free: (a: number, b: number) => void;
   readonly flowfield_get: (a: number, b: number, c: number) => number;
   readonly flowfield_set: (a: number, b: number, c: number, d: number) => void;
   readonly flowfield_getDirections: (a: number, b: number, c: number, d: number) => void;
   readonly flowfield_setDirections: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly flowfield_addDirection: (a: number, b: number, c: number, d: number) => void;
-  readonly js_path_to_mono_flow_field_origin: (a: number, b: number) => number;
-  readonly __wbg_monoflowfield_free: (a: number, b: number) => void;
-  readonly monoflowfield_get: (a: number, b: number, c: number) => number;
-  readonly monoflowfield_set: (a: number, b: number, c: number, d: number) => void;
+  readonly js_bfs_distance_map: (a: number, b: number, c: number) => number;
+  readonly js_dijkstra_multiroom_distance_map: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+  readonly js_dijkstra_multiroom_flow_field: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+  readonly js_bfs_multiroom_distance_map: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+  readonly js_dijkstra_flow_field: (a: number, b: number, c: number) => number;
+  readonly js_dijkstra_multiroom_mono_flow_field: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+  readonly js_path_to_multiroom_distance_map_origin: (a: number, b: number) => number;
   readonly __wbg_clockworkcostmatrix_free: (a: number, b: number) => void;
   readonly clockworkcostmatrix_new: (a: number) => number;
   readonly clockworkcostmatrix_get: (a: number, b: number, c: number) => number;
   readonly clockworkcostmatrix_set: (a: number, b: number, c: number, d: number) => void;
-  readonly js_dijkstra_distance_map: (a: number, b: number, c: number) => number;
+  readonly js_bfs_flow_field: (a: number, b: number, c: number) => number;
+  readonly js_path_to_mono_flow_field_origin: (a: number, b: number) => number;
+  readonly js_path_to_multiroom_mono_flow_field_origin: (a: number, b: number) => number;
+  readonly __wbg_multiroomdistancemap_free: (a: number, b: number) => void;
+  readonly multiroomdistancemap_js_new: () => number;
+  readonly multiroomdistancemap_get: (a: number, b: number) => number;
+  readonly multiroomdistancemap_set: (a: number, b: number, c: number) => void;
+  readonly multiroomdistancemap_get_rooms: (a: number, b: number) => void;
+  readonly multiroomdistancemap_get_room: (a: number, b: number) => number;
+  readonly __wbg_multiroommonoflowfield_free: (a: number, b: number) => void;
+  readonly multiroommonoflowfield_get: (a: number, b: number) => number;
+  readonly multiroommonoflowfield_set: (a: number, b: number, c: number) => void;
+  readonly multiroommonoflowfield_getRooms: (a: number, b: number) => void;
+  readonly multiroommonoflowfield_getRoom: (a: number, b: number) => number;
+  readonly multiroommonoflowfield_js_new: () => number;
+  readonly js_bfs_multiroom_mono_flow_field: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
+  readonly __wbg_monoflowfield_free: (a: number, b: number) => void;
+  readonly monoflowfield_get: (a: number, b: number, c: number) => number;
+  readonly monoflowfield_set: (a: number, b: number, c: number, d: number) => void;
   readonly js_bfs_mono_flow_field: (a: number, b: number, c: number) => number;
   readonly js_path_to_distance_map_origin: (a: number, b: number) => number;
+  readonly js_path_to_multiroom_flow_field_origin: (a: number, b: number) => number;
+  readonly __wbg_multiroomflowfield_free: (a: number, b: number) => void;
+  readonly multiroomflowfield_js_new: () => number;
+  readonly multiroomflowfield_get: (a: number, b: number) => number;
+  readonly multiroomflowfield_set: (a: number, b: number, c: number) => void;
+  readonly multiroomflowfield_getRooms: (a: number, b: number) => void;
+  readonly multiroomflowfield_getRoom: (a: number, b: number) => number;
+  readonly multiroomflowfield_getDirections: (a: number, b: number, c: number) => void;
+  readonly multiroomflowfield_setDirections: (a: number, b: number, c: number, d: number) => void;
+  readonly multiroomflowfield_addDirection: (a: number, b: number, c: number) => void;
+  readonly js_dijkstra_mono_flow_field: (a: number, b: number, c: number) => number;
   readonly __wbg_distancemap_free: (a: number, b: number) => void;
   readonly distancemap_toArray: (a: number, b: number) => void;
   readonly distancemap_get: (a: number, b: number, c: number) => number;
   readonly distancemap_set: (a: number, b: number, c: number, d: number) => void;
+  readonly __wbg_path_free: (a: number, b: number) => void;
+  readonly __wbg_pathfatigue_free: (a: number, b: number) => void;
+  readonly path_add: (a: number, b: number) => void;
+  readonly path_get: (a: number, b: number) => number;
+  readonly path_len: (a: number) => number;
+  readonly path_find_next_index: (a: number, b: number) => number;
+  readonly path_to_array: (a: number, b: number) => void;
+  readonly path_to_array_reversed: (a: number, b: number) => void;
+  readonly pathfatigue_new: (a: number) => number;
+  readonly pathfatigue_refresh: (a: number, b: number) => void;
+  readonly pathfatigue_moveTime: (a: number, b: number) => number;
   readonly version: (a: number) => void;
   readonly get_range: (a: number, b: number) => number;
-  readonly js_bfs_distance_map: (a: number, b: number, c: number) => number;
-  readonly js_bfs_flow_field: (a: number, b: number, c: number) => number;
-  readonly js_dijkstra_mono_flow_field: (a: number, b: number, c: number) => number;
-  readonly js_path_to_flow_field_origin: (a: number, b: number) => number;
+  readonly pathfatigue_len: (a: number) => number;
   readonly __wbg_searchgoal_free: (a: number, b: number) => void;
   readonly searchgoal_pos: (a: number) => number;
   readonly searchgoal_range: (a: number) => number;
-  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
-  readonly __wbindgen_exn_store: (a: number) => void;
+  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+  readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
 }
 
 export type SyncInitInput = BufferSource | WebAssembly.Module;

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

@@ -1,4 +1,6 @@
 import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
+import { ClockworkDistanceMap } from './distanceMap';
+import { ClockworkMultiroomDistanceMap } from './multiroomDistanceMap';
 /**
  * Generate a [distance map](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
  * using a breadth-first search algorithm.
@@ -17,4 +19,28 @@ import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
  * @param costMatrix - The cost matrix to use for the flow field.
  * @returns The flow field.
  */
-export declare function bfsDistanceMap(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").DistanceMap;
+export declare function bfsDistanceMap(start: RoomPosition[], costMatrix: ClockworkCostMatrix): ClockworkDistanceMap;
+/**
+ * Create a distance map for the given start positions, using a breadth-first search.
+ * This does not factor in terrain costs (treating anything less than 255 in the cost
+ * matrix as passable), so it's faster but less useful than Dijkstra's algorithm.
+ *
+ * This calculates a distance map across multiple rooms, with a few configurable limits:
+ * - `maxTiles`: The maximum number of tiles to explore.
+ * - `maxRooms`: The maximum number of rooms to explore.
+ * - `maxRoomDistance`: Don't explore rooms further (in Manhattan distance) than this.
+ * - `maxTileDistance`: Don't explore tiles further (in Chebyshev distance) than this.
+ *
+ * At least one of these limits must be set.
+ *
+ * @param start - The starting positions.
+ * @param options - The options for the distance map.
+ * @returns A multi-room distance map.
+ */
+export declare function bfsMultiroomDistanceMap(start: RoomPosition[], { costMatrixCallback, maxTiles, maxRooms, maxRoomDistance, maxTileDistance }: {
+    costMatrixCallback: (room: string) => ClockworkCostMatrix | undefined;
+    maxTiles?: number;
+    maxRooms?: number;
+    maxRoomDistance?: number;
+    maxTileDistance?: number;
+}): ClockworkMultiroomDistanceMap;

package/dist/src/wrappers/bfsFlowField.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 a breadth-first search algorithm.
@@ -14,7 +18,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 bfsFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").FlowField;
+export declare function bfsFlowField(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 a breadth-first search algorithm.
@@ -33,4 +37,48 @@ export declare function bfsFlowField(start: RoomPosition[], costMatrix: Clockwor
  * @param costMatrix - The cost matrix to use for the flow field.
  * @returns The flow field.
  */
-export declare function bfsMonoFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").MonoFlowField;
+export declare function bfsMonoFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): ClockworkMonoFlowField;
+/**
+ * Generate a multiroom flow field for a set of positions using a breadth-first search algorithm.
+ *
+ * The BFS algorithm doesn't include variable costs, and only considers
+ * values of 255 (impassible) in the provided cost matrix. Any other
+ * values are ignored.
+ *
+ * This might be useful for creeps with only MOVE parts and/or empty
+ * CARRY parts, which don't generate fatigue.
+ *
+ * @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 bfsMultiroomFlowField(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 a breadth-first search algorithm.
+ *
+ * The BFS algorithm doesn't include variable costs, and only considers
+ * values of 255 (impassible) in the provided cost matrix. Any other
+ * values are ignored.
+ *
+ * This might be useful for creeps with only MOVE parts and/or empty
+ * CARRY parts, which don't generate fatigue.
+ *
+ * @param start - The starting positions.
+ * @param getCostMatrix - 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 bfsMultiroomMonoFlowField(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/dijkstraDistanceMap.d.ts

@@ -1,4 +1,6 @@
 import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
+import { ClockworkDistanceMap } from './distanceMap';
+import { ClockworkMultiroomDistanceMap } from './multiroomDistanceMap';
 /**
  * Generate a [distance map](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
  * using Dijkstra's algorithm.
@@ -15,4 +17,27 @@ import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
  * @param costMatrix - The cost matrix to use for the flow field.
  * @returns The flow field.
  */
-export declare function dijkstraDistanceMap(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").DistanceMap;
+export declare function dijkstraDistanceMap(start: RoomPosition[], costMatrix: ClockworkCostMatrix): ClockworkDistanceMap;
+/**
+ * Create a distance map for the given start positions, using Dijkstra's algorithm to
+ * factor in terrain costs (0-255, where 255 is impassable).
+ *
+ * This calculates a distance map across multiple rooms, with a few configurable limits:
+ * - `maxTiles`: The maximum number of tiles to explore.
+ * - `maxRooms`: The maximum number of rooms to explore.
+ * - `maxRoomDistance`: Don't explore rooms further (in Manhattan distance) than this.
+ * - `maxTileDistance`: Don't explore tiles further (in accumulated cost) than this.
+ *
+ * At least one of these limits must be set.
+ *
+ * @param start - The starting positions.
+ * @param options - The options for the distance map.
+ * @returns A multi-room distance map.
+ */
+export declare function dijkstraMultiroomDistanceMap(start: RoomPosition[], { costMatrixCallback, maxTiles, maxRooms, maxRoomDistance, maxTileDistance }: {
+    costMatrixCallback: (room: string) => ClockworkCostMatrix | undefined;
+    maxTiles?: number;
+    maxRooms?: number;
+    maxRoomDistance?: number;
+    maxTileDistance?: number;
+}): ClockworkMultiroomDistanceMap;