screeps-clockwork 0.2.0 → 0.4.0

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

@@ -0,0 +1,484 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * WASM wrapper for the Dijkstra flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {FlowField}
+ */
+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;
+/**
+ * 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;
+/**
+ * WASM wrapper for the BFS mono flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {MonoFlowField}
+ */
+export function js_bfs_mono_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): MonoFlowField;
+/**
+ * @param {number} start
+ * @param {DistanceMap} distance_map
+ * @returns {Path}
+ */
+export function js_path_to_distance_map_origin(start: number, distance_map: DistanceMap): Path;
+/**
+ * @returns {string}
+ */
+export function version(): string;
+/**
+ * Exports the global range calculation between two positions.
+ * @param {number} packed_pos_1
+ * @param {number} packed_pos_2
+ * @returns {number}
+ */
+export function get_range(packed_pos_1: number, packed_pos_2: number): number;
+/**
+ * WASM wrapper for the BFS distance map function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {DistanceMap}
+ */
+export function js_bfs_distance_map(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): DistanceMap;
+/**
+ * WASM wrapper for the BFS flow field function.
+ * @param {Uint32Array} start_packed
+ * @param {ClockworkCostMatrix} cost_matrix
+ * @returns {FlowField}
+ */
+export function js_bfs_flow_field(start_packed: Uint32Array, cost_matrix: ClockworkCostMatrix): FlowField;
+/**
+ * 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;
+/**
+ * @param {number} start
+ * @param {FlowField} flow_field
+ * @returns {Path}
+ */
+export function js_path_to_flow_field_origin(start: number, flow_field: FlowField): Path;
+/**
+ * Translates `COLOR_*` and `COLORS_ALL` constants.
+ */
+export enum Color {
+  Red = 1,
+  Purple = 2,
+  Blue = 3,
+  Cyan = 4,
+  Green = 5,
+  Yellow = 6,
+  Orange = 7,
+  Brown = 8,
+  Grey = 9,
+  White = 10,
+}
+/**
+ * Translates the `DENSITY_*` constants.
+ */
+export enum Density {
+  Low = 1,
+  Moderate = 2,
+  High = 3,
+  Ultra = 4,
+}
+/**
+ * Translates direction constants.
+ */
+export enum Direction {
+  Top = 1,
+  TopRight = 2,
+  Right = 3,
+  BottomRight = 4,
+  Bottom = 5,
+  BottomLeft = 6,
+  Left = 7,
+  TopLeft = 8,
+}
+/**
+ * Type used for when the game returns a direction to an exit.
+ *
+ * Restricted more than `Direction` in that it can't be diagonal. Used as the
+ * result of [`Room::find_exit_to`].
+ *
+ * Can be converted to [`Find`] for immediate use of [`Room::find`]
+ * and [`Direction`].
+ *
+ * [`Room::find`]: crate::objects::Room::find
+ * [`Room::find_exit_to`]: crate::objects::Room::find_exit_to
+ */
+export enum ExitDirection {
+  Top = 1,
+  Right = 3,
+  Bottom = 5,
+  Left = 7,
+}
+/**
+ * Translates `FIND_*` constants for interal API calls
+ *
+ * Unless you're storing the type of find constant to be used for a call, you
+ * likely want the constants which implement the `FindConstant` trait to make
+ * calls to find methods.
+ *
+ * This is hidden from the documentation to avoid confusion due to its narrow
+ * use case, but wasm_bindgen requires it remain public.
+ */
+export enum Find {
+  /**
+   * Find all exit positions at the top of the room
+   */
+  ExitTop = 1,
+  ExitRight = 3,
+  ExitBottom = 5,
+  ExitLeft = 7,
+  Exit = 10,
+  Creeps = 101,
+  MyCreeps = 102,
+  HostileCreeps = 103,
+  SourcesActive = 104,
+  Sources = 105,
+  DroppedResources = 106,
+  Structures = 107,
+  MyStructures = 108,
+  HostileStructures = 109,
+  Flags = 110,
+  ConstructionSites = 111,
+  MySpawns = 112,
+  HostileSpawns = 113,
+  MyConstructionSites = 114,
+  HostileConstructionSites = 115,
+  Minerals = 116,
+  Nukes = 117,
+  Tombstones = 118,
+  PowerCreeps = 119,
+  MyPowerCreeps = 120,
+  HostilePowerCreeps = 121,
+  Deposits = 122,
+  Ruins = 123,
+  ScoreContainers = 10011,
+  ScoreCollectors = 10012,
+  SymbolContainers = 10021,
+  SymbolDecoders = 10022,
+  Reactors = 10051,
+}
+/**
+ * Translates the `EFFECT_*` constants, which are natural effect types
+ */
+export enum NaturalEffectType {
+  Invulnerability = 1001,
+  CollapseTimer = 1002,
+}
+/**
+ * Translates the `PWR_*` constants, which are types of powers used by power
+ * creeps
+ */
+export enum PowerType {
+  GenerateOps = 1,
+  OperateSpawn = 2,
+  OperateTower = 3,
+  OperateStorage = 4,
+  OperateLab = 5,
+  OperateExtension = 6,
+  OperateObserver = 7,
+  OperateTerminal = 8,
+  DisruptSpawn = 9,
+  DisruptTower = 10,
+  Shield = 12,
+  RegenSource = 13,
+  RegenMineral = 14,
+  DisruptTerminal = 15,
+  OperatePower = 16,
+  Fortify = 17,
+  OperateController = 18,
+  OperateFactory = 19,
+}
+/**
+ * Translates `TERRAIN_*` constants.
+ */
+export enum Terrain {
+  Plain = 0,
+  Wall = 1,
+  Swamp = 2,
+}
+/**
+ * A wrapper around the `LocalCostMatrix` type from the Screeps API.
+ * Instances can be passed between WASM and JS as a pointer, using the
+ * methods to get and set values, rather than copying the entire matrix.
+ */
+export class ClockworkCostMatrix {
+  free(): void;
+  /**
+   * 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;
+}
+/**
+ * Maps a distance value onto individual room tile positions.
+ */
+export class DistanceMap {
+  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;
+}
+/**
+ * A flow field is a 50x50 grid (representing a room), representing viable directions
+ * to travel to reach a particular target (or targets). A given tile may have multiple
+ * equally valid directions, so we represent this as a bitfield (where each bit in an
+ * 8-bit unsigned integer represents a direction that is either viable or not).
+ */
+export class FlowField {
+  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;
+}
+/**
+ * A flow field is a 50x50 grid (representing a room), representing viable directions
+ * to travel to reach a particular target (or targets). A mono flow field only stores
+ * a single direction for each tile, so we represent this as 4 bits of an unsigned
+ * integer (0 for no direction, 1 for TOP, etc.).
+ */
+export class MonoFlowField {
+  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.
+ */
+export class Path {
+  free(): void;
+  /**
+   * @param {number} packed_position
+   */
+  add(packed_position: number): void;
+  /**
+   * @param {number} index
+   * @returns {number | undefined}
+   */
+  get(index: number): number | undefined;
+  /**
+   * @returns {number}
+   */
+  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;
+}
+/**
+ * Tracks fatigue cost for each position in a path. Used to calculate move time
+ * for a given creep build.
+ */
+export class PathFatigue {
+  free(): void;
+  /**
+   * @param {Path} path
+   */
+  constructor(path: Path);
+  /**
+   * Refreshes fatigue cost for each position in the path. If the PathFatigue
+   * has not been initialized yet, every position's fatigue cost will be set,
+   * even if there is no vision in the room, based on terrain costs. If the
+   * 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 {
+  free(): void;
+  readonly pos: any;
+  readonly range: number;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+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 __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 __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_mono_flow_field: (a: number, b: number, c: number) => number;
+  readonly js_path_to_distance_map_origin: (a: number, b: 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 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 __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_free: (a: number, b: number, c: number) => void;
+  readonly __wbindgen_malloc: (a: number, b: number) => number;
+  readonly __wbindgen_exn_store: (a: number) => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+/**
+* Instantiates the given `module`, which can either be bytes or
+* a precompiled `WebAssembly.Module`.
+*
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+*
+* @returns {InitOutput}
+*/
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+* for everything else, calls `WebAssembly.instantiate` directly.
+*
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+*
+* @returns {Promise<InitOutput>}
+*/
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

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

@@ -1,4 +1,4 @@
-import { ClockworkCostMatrix } from '../../wasm';
+import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
 /**
  * Generate a [distance map](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
  * using a breadth-first search algorithm.
@@ -10,8 +10,11 @@ import { ClockworkCostMatrix } from '../../wasm';
  * This might be useful for creeps with only MOVE parts and/or empty
  * CARRY parts, which don't generate fatigue.
  *
+ * Note that the `roomName` on start positions is ignored - all positions
+ * are assumed to be in the same room as the cost matrix.
+ *
  * @param start - The starting positions.
  * @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").DistanceMap;
+export declare function bfsDistanceMap(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").DistanceMap;

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

@@ -1,4 +1,4 @@
-import { ClockworkCostMatrix } from '../../wasm';
+import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
 /**
  * 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 +14,7 @@ import { ClockworkCostMatrix } from '../../wasm';
  * @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").FlowField;
+export declare function bfsFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").FlowField;
 /**
  * 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.
@@ -26,8 +26,11 @@ export declare function bfsFlowField(start: RoomPosition[], costMatrix: Clockwor
  * This might be useful for creeps with only MOVE parts and/or empty
  * CARRY parts, which don't generate fatigue.
  *
+ * Note that the `roomName` on start positions is ignored - all positions
+ * are assumed to be in the same room as the cost matrix.
+ *
  * @param start - The starting positions.
  * @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").MonoFlowField;
+export declare function bfsMonoFlowField(start: RoomPosition[], costMatrix: ClockworkCostMatrix): import("../wasm/screeps_clockwork").MonoFlowField;

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

@@ -1,4 +1,4 @@
-import { ClockworkCostMatrix } from '../../wasm/screeps_clockwork';
+import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
 /**
  * Generate a [distance map](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
  * using Dijkstra's algorithm.
@@ -8,8 +8,11 @@ import { ClockworkCostMatrix } from '../../wasm/screeps_clockwork';
  * 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.
  *
+ * Note that the `roomName` on start positions is ignored - all positions
+ * are assumed to be in the same room as the cost matrix.
+ *
  * @param start - The starting positions.
  * @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): import("../wasm/screeps_clockwork").DistanceMap;

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

@@ -1,4 +1,4 @@
-import { ClockworkCostMatrix } from '../../wasm/screeps_clockwork';
+import { ClockworkCostMatrix } from '../wasm/screeps_clockwork';
 /**
  * Generate a [flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html) for a set of positions
  * using Dijkstra's algorithm.
@@ -12,7 +12,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): import("../wasm/screeps_clockwork").FlowField;
 /**
  * Generate a [mono-directional flow field](https://glitchassassin.github.io/screeps-clockwork/primitives/flowfield.html)
  * for a set of positions using Dijkstra's algorithm.
@@ -22,8 +22,11 @@ export declare function dijkstraFlowField(start: RoomPosition[], costMatrix: Clo
  * 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.
  *
+ * Note that the `roomName` on start positions is ignored - all positions
+ * are assumed to be in the same room as the cost matrix.
+ *
  * @param start - The starting positions.
  * @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): import("../wasm/screeps_clockwork").MonoFlowField;

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

@@ -0,0 +1,26 @@
+import { Path as ClockworkPath } from '../wasm/screeps_clockwork';
+export declare class Path {
+    private readonly path;
+    constructor(path: ClockworkPath);
+    [Symbol.iterator](): {
+        next: () => {
+            value: RoomPosition;
+            done: boolean;
+        };
+    };
+    /**
+     * Iterate over the path in reverse order
+     */
+    reversed(): Generator<never, {
+        next: () => {
+            value: RoomPosition;
+            done: boolean;
+        };
+    }, unknown>;
+    get(index: number): RoomPosition;
+    get length(): number;
+    findNextIndex(index: number): number | undefined;
+    toArray(): RoomPosition[];
+    toArrayReversed(): RoomPosition[];
+    free(): void;
+}

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,3 @@
+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

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

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "screeps-clockwork",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "A WASM movement library for Screeps",
   "main": "dist/index.js",
   "types": "dist/src/index.d.ts",
   "scripts": {
     "build": "run-s build:lib build:src",
-    "build:lib": "wasm-pack build --target web --out-dir wasm --config build.rustflags=[\\'-Ctarget-feature=-reference-types\\',\\'-Ctarget-feature=-multivalue\\',\\'-Ctarget-feature=-sign-ext\\'] -Z build-std=std,panic_abort",
+    "build:lib": "wasm-pack build --target web --out-dir src/wasm --config build.rustflags=[\\'-Ctarget-feature=-reference-types\\',\\'-Ctarget-feature=-multivalue\\',\\'-Ctarget-feature=-sign-ext\\'] -Z build-std=std,panic_abort",
     "build:src": "rollup -c",
     "build:docs": "typedoc",
     "watch": "run-s build watch:both",
     "watch:lib": "cargo-watch -w lib -s \"npm run build:lib\"",
-    "watch:src": "wait-on wasm/screeps_clockwork_bg.wasm && rollup -cw",
+    "watch:src": "wait-on src/wasm/screeps_clockwork_bg.wasm && rollup -cw",
     "watch:pserver": "rollup -cw --environment DEST:pserver",
     "watch:both": "run-p watch:lib watch:pserver"
   },