screeps-clockwork 0.6.0 → 0.7.1

package/README.md

@@ -93,6 +93,7 @@ To set up the local Screeps server, you'll need to have docker installed:
 
 ```bash
 cp .env.sample .env # fill this out with the path to your Screeps .nw package and Steam key
+cp screeps.sample.json screeps.json # optionally, override this to connect to your own local Screeps server
 ./reset-docker.sh
 ```
 

package/dist/index.js

@@ -188,9 +188,9 @@ function addBorrowedObject(obj) {
  * @param {number} max_rooms
  * @param {number} max_ops
  * @param {number} max_path_cost
- * @param {Uint32Array | undefined} [any_of_destinations]
- * @param {Uint32Array | undefined} [all_of_destinations]
- * @returns {MultiroomDistanceMap}
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
  */
 function js_astar_multiroom_distance_map(start_packed, get_cost_matrix, max_rooms, max_ops, max_path_cost, any_of_destinations, all_of_destinations) {
     try {
@@ -201,12 +201,17 @@ function js_astar_multiroom_distance_map(start_packed, get_cost_matrix, max_room
         var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
         var len2 = WASM_VECTOR_LEN;
         const ret = wasm.js_astar_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_rooms, max_ops, max_path_cost, ptr1, len1, ptr2, len2);
-        return MultiroomDistanceMap.__wrap(ret);
+        return SearchResult.__wrap(ret);
     } finally {
         heap[stack_pointer++] = undefined;
     }
 }
 
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
 function _assertClass(instance, klass) {
     if (!(instance instanceof klass)) {
         throw new Error(`expected instance of ${klass.name}`);
@@ -237,33 +242,14 @@ function getArrayU16FromWasm0(ptr, len) {
     return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
 }
 /**
- * @param {Uint32Array} start_packed
- * @param {Function} get_cost_matrix
- * @param {number} max_ops
- * @param {number} max_rooms
- * @param {number} max_path_cost
- * @param {Uint32Array | undefined} [any_of_destinations]
- * @param {Uint32Array | undefined} [all_of_destinations]
- * @returns {MultiroomDistanceMap}
+ * @param {number} start
+ * @param {MultiroomFlowField} flow_field
+ * @returns {Path}
  */
-function js_dijkstra_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, max_rooms, max_path_cost, any_of_destinations, all_of_destinations) {
-    try {
-        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        var ptr1 = isLikeNone(any_of_destinations) ? 0 : passArray32ToWasm0(any_of_destinations, wasm.__wbindgen_malloc);
-        var len1 = WASM_VECTOR_LEN;
-        var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
-        var len2 = WASM_VECTOR_LEN;
-        const ret = wasm.js_dijkstra_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_ops, max_rooms, max_path_cost, ptr1, len1, ptr2, len2);
-        return MultiroomDistanceMap.__wrap(ret);
-    } finally {
-        heap[stack_pointer++] = undefined;
-    }
-}
-
-function getArrayU32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+function js_path_to_multiroom_flow_field_origin(start, flow_field) {
+    _assertClass(flow_field, MultiroomFlowField);
+    const ret = wasm.js_path_to_multiroom_flow_field_origin(start, flow_field.__wbg_ptr);
+    return Path.__wrap(ret);
 }
 
 function getArrayJsValueFromWasm0(ptr, len) {
@@ -285,6 +271,55 @@ function passArrayJsValueToWasm0(array, malloc) {
     WASM_VECTOR_LEN = array.length;
     return ptr;
 }
+/**
+ * @param {number} room_name
+ * @param {number | null} [plain_cost]
+ * @param {number | null} [swamp_cost]
+ * @param {number | null} [wall_cost]
+ * @returns {ClockworkCostMatrix}
+ */
+function get_terrain_cost_matrix(room_name, plain_cost, swamp_cost, wall_cost) {
+    const ret = wasm.get_terrain_cost_matrix(room_name, isLikeNone(plain_cost) ? 0xFFFFFF : plain_cost, isLikeNone(swamp_cost) ? 0xFFFFFF : swamp_cost, isLikeNone(wall_cost) ? 0xFFFFFF : wall_cost);
+    return ClockworkCostMatrix.__wrap(ret);
+}
+
+/**
+ * Creates a flow field for the given distance map.
+ * @param {MultiroomDistanceMap} distance_map
+ * @returns {MultiroomFlowField}
+ */
+function multiroomFlowField(distance_map) {
+    _assertClass(distance_map, MultiroomDistanceMap);
+    var ptr0 = distance_map.__destroy_into_raw();
+    const ret = wasm.multiroomFlowField(ptr0);
+    return MultiroomFlowField.__wrap(ret);
+}
+
+/**
+ * @param {Uint32Array} start_packed
+ * @param {Function} get_cost_matrix
+ * @param {number} max_ops
+ * @param {number} max_rooms
+ * @param {number} max_path_cost
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
+ */
+function js_dijkstra_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, max_rooms, max_path_cost, any_of_destinations, all_of_destinations) {
+    try {
+        const ptr0 = passArray32ToWasm0(start_packed, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(any_of_destinations) ? 0 : passArray32ToWasm0(any_of_destinations, wasm.__wbindgen_malloc);
+        var len1 = WASM_VECTOR_LEN;
+        var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
+        var len2 = WASM_VECTOR_LEN;
+        const ret = wasm.js_dijkstra_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_ops, max_rooms, max_path_cost, ptr1, len1, ptr2, len2);
+        return SearchResult.__wrap(ret);
+    } finally {
+        heap[stack_pointer++] = undefined;
+    }
+}
+
 /**
  * WASM wrapper for the BFS multiroom distance map function.
  *
@@ -305,9 +340,9 @@ function passArrayJsValueToWasm0(array, malloc) {
  * @param {number} max_ops
  * @param {number} max_rooms
  * @param {number} max_path_cost
- * @param {Uint32Array | undefined} [any_of_destinations]
- * @param {Uint32Array | undefined} [all_of_destinations]
- * @returns {MultiroomDistanceMap}
+ * @param {Uint32Array | null} [any_of_destinations]
+ * @param {Uint32Array | null} [all_of_destinations]
+ * @returns {SearchResult}
  */
 function js_bfs_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, max_rooms, max_path_cost, any_of_destinations, all_of_destinations) {
     try {
@@ -318,35 +353,12 @@ function js_bfs_multiroom_distance_map(start_packed, get_cost_matrix, max_ops, m
         var ptr2 = isLikeNone(all_of_destinations) ? 0 : passArray32ToWasm0(all_of_destinations, wasm.__wbindgen_malloc);
         var len2 = WASM_VECTOR_LEN;
         const ret = wasm.js_bfs_multiroom_distance_map(ptr0, len0, addBorrowedObject(get_cost_matrix), max_ops, max_rooms, max_path_cost, ptr1, len1, ptr2, len2);
-        return MultiroomDistanceMap.__wrap(ret);
+        return SearchResult.__wrap(ret);
     } finally {
         heap[stack_pointer++] = undefined;
     }
 }
 
-/**
- * @param {number} start
- * @param {MultiroomDistanceMap} distance_map
- * @returns {Path}
- */
-function js_path_to_multiroom_distance_map_origin(start, distance_map) {
-    _assertClass(distance_map, MultiroomDistanceMap);
-    const ret = wasm.js_path_to_multiroom_distance_map_origin(start, distance_map.__wbg_ptr);
-    return Path.__wrap(ret);
-}
-
-/**
- * @param {number} room_name
- * @param {number | undefined} [plain_cost]
- * @param {number | undefined} [swamp_cost]
- * @param {number | undefined} [wall_cost]
- * @returns {ClockworkCostMatrix}
- */
-function get_terrain_cost_matrix(room_name, plain_cost, swamp_cost, wall_cost) {
-    const ret = wasm.get_terrain_cost_matrix(room_name, isLikeNone(plain_cost) ? 0xFFFFFF : plain_cost, isLikeNone(swamp_cost) ? 0xFFFFFF : swamp_cost, isLikeNone(wall_cost) ? 0xFFFFFF : wall_cost);
-    return ClockworkCostMatrix.__wrap(ret);
-}
-
 /**
  * @returns {string}
  */
@@ -392,25 +404,13 @@ function multiroomMonoFlowField(distance_map) {
 
 /**
  * @param {number} start
- * @param {MultiroomFlowField} flow_field
- * @returns {Path}
- */
-function js_path_to_multiroom_flow_field_origin(start, flow_field) {
-    _assertClass(flow_field, MultiroomFlowField);
-    const ret = wasm.js_path_to_multiroom_flow_field_origin(start, flow_field.__wbg_ptr);
-    return Path.__wrap(ret);
-}
-
-/**
- * Creates a flow field for the given distance map.
  * @param {MultiroomDistanceMap} distance_map
- * @returns {MultiroomFlowField}
+ * @returns {Path}
  */
-function multiroomFlowField(distance_map) {
+function js_path_to_multiroom_distance_map_origin(start, distance_map) {
     _assertClass(distance_map, MultiroomDistanceMap);
-    var ptr0 = distance_map.__destroy_into_raw();
-    const ret = wasm.multiroomFlowField(ptr0);
-    return MultiroomFlowField.__wrap(ret);
+    const ret = wasm.js_path_to_multiroom_distance_map_origin(start, distance_map.__wbg_ptr);
+    return Path.__wrap(ret);
 }
 
 /**
@@ -600,7 +600,7 @@ 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]
+     * @param {number | null} [_default]
      */
     constructor(_default) {
         const ret = wasm.clockworkcostmatrix_new(isLikeNone(_default) ? 0xFFFFFF : _default);
@@ -828,7 +828,7 @@ class MonoFlowField {
      * Set the direction for a given coordinate.
      * @param {number} x
      * @param {number} y
-     * @param {Direction | undefined} [value]
+     * @param {Direction | null} [value]
      */
     set(x, y, value) {
         wasm.monoflowfield_set(this.__wbg_ptr, x, y, isLikeNone(value) ? 0 : value);
@@ -1081,7 +1081,7 @@ class MultiroomMonoFlowField {
     /**
      * Sets the direction at a given position
      * @param {number} packed_pos
-     * @param {Direction | undefined} [direction]
+     * @param {Direction | null} [direction]
      */
     set(packed_pos, direction) {
         wasm.multiroommonoflowfield_set(this.__wbg_ptr, packed_pos, isLikeNone(direction) ? 0 : direction);
@@ -1216,26 +1216,91 @@ class Path {
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_searchgoal_free(ptr >>> 0, 1));
 
+const SearchResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_searchresult_free(ptr >>> 0, 1));
+/**
+ * A distance map search returns both the distance map (filled out
+ * with all tiles explored) and the targets found. These aren't necessarily
+ * the same positions specified as targets - if the target range is 5, then
+ * this is the first position in range 5 of the target. If multiple targets
+ * are specified, and you care about matching the found target with one of
+ * the original targets, you can iterate through your list and figure out the
+ * ones that are in range of the found target(s).
+ */
+class SearchResult {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SearchResult.prototype);
+        obj.__wbg_ptr = ptr;
+        SearchResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SearchResultFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_searchresult_free(ptr, 0);
+    }
+    /**
+     * @returns {MultiroomDistanceMap}
+     */
+    get distance_map() {
+        const ret = wasm.searchresult_distance_map(this.__wbg_ptr);
+        return MultiroomDistanceMap.__wrap(ret);
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get found_targets() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.searchresult_found_targets(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_free(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get ops() {
+        const ret = wasm.searchresult_ops(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
-    imports.wbg.__wbg_buffer_61b7ce01341d7f88 = function(arg0) {
+    imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
         const ret = getObject(arg0).buffer;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_call_500db948e69c7330 = function() { return handleError(function (arg0, arg1, arg2) {
+    imports.wbg.__wbg_call_7cccdd69e0791ae2 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_ceil_5cd004a49ac02e2f = function(arg0) {
+    imports.wbg.__wbg_ceil_2a411b0e70cc0baf = function(arg0) {
         const ret = Math.ceil(arg0);
         return ret;
     };
-    imports.wbg.__wbg_clockworkcostmatrixgetpointer_c0e9996555799972 = function(arg0) {
+    imports.wbg.__wbg_clockworkcostmatrixgetpointer_ac59edc2cad584d6 = function(arg0) {
         const ret = clockworkcostmatrix_get_pointer(takeObject(arg0));
         return ret;
     };
-    imports.wbg.__wbg_create_861381d799b454bc = function(arg0) {
+    imports.wbg.__wbg_create_cfe43ccc88c64e0a = function(arg0) {
         const ret = Object.create(getObject(arg0));
         return addHeapObject(ret);
     };
@@ -1262,7 +1327,7 @@ function __wbg_get_imports() {
         const ret = getObject(arg0).get(arg1, arg2);
         return ret;
     };
-    imports.wbg.__wbg_get_9aa3dff3f0266054 = function(arg0, arg1) {
+    imports.wbg.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
         const ret = getObject(arg0)[arg1 >>> 0];
         return addHeapObject(ret);
     };
@@ -1270,11 +1335,11 @@ function __wbg_get_imports() {
         const ret = getObject(arg0)[getObject(arg1)];
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_length_d65cf0786bfc5739 = function(arg0) {
+    imports.wbg.__wbg_length_e2d2a49132c1b256 = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;
     };
-    imports.wbg.__wbg_log_261344311425094c = function(arg0, arg1) {
+    imports.wbg.__wbg_log_223889c5580129ef = function(arg0, arg1) {
         console.log(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg_lookFor_04c5885fea38e9b2 = function() { return handleError(function (arg0, arg1) {
@@ -1289,7 +1354,7 @@ function __wbg_get_imports() {
         const ret = new Room.Terrain(getObject(arg0));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_newwithbyteoffsetandlength_ba35896968751d91 = function(arg0, arg1, arg2) {
+    imports.wbg.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
         const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
         return addHeapObject(ret);
     };
@@ -1827,6 +1892,21 @@ class ClockworkMultiroomDistanceMap {
     }
 }
 
+function fromPackedSearchResult(result) {
+    const foundTargets = result.found_targets.reduce((acc, pos) => {
+        acc.push(fromPacked(pos));
+        return acc;
+    }, []);
+    const distanceMap = new ClockworkMultiroomDistanceMap(result.distance_map);
+    const ops = result.ops;
+    result.free();
+    return {
+        distanceMap,
+        foundTargets,
+        ops
+    };
+}
+
 /**
  * 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
@@ -1848,8 +1928,18 @@ function astarMultiroomDistanceMap(start, { costMatrixCallback, maxRooms = MAX_U
         throw new Error('At least one of maxRooms, maxOps, maxPathCost, anyOfDestinations, or allOfDestinations must be set');
     }
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_astar_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxRooms, maxOps, maxPathCost, anyOfDestinations ? new Uint32Array(anyOfDestinations.map(pos => pos.__packedPos)) : undefined, allOfDestinations ? new Uint32Array(allOfDestinations.map(pos => pos.__packedPos)) : undefined);
-    return new ClockworkMultiroomDistanceMap(result);
+    const result = js_astar_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxRooms, maxOps, maxPathCost, anyOfDestinations
+        ? new Uint32Array(anyOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined, allOfDestinations
+        ? new Uint32Array(allOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined);
+    return fromPackedSearchResult(result);
 }
 
 /**
@@ -1873,8 +1963,18 @@ function bfsMultiroomDistanceMap(start, { costMatrixCallback, maxOps = MAX_USIZE
         throw new Error('At least one of maxOps, maxRooms, maxRoomDistance, maxPathCost, anyOfDestinations, or allOfDestinations must be set');
     }
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_bfs_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxOps, maxRooms, maxPathCost, anyOfDestinations ? new Uint32Array(anyOfDestinations.map(pos => pos.__packedPos)) : undefined, allOfDestinations ? new Uint32Array(allOfDestinations.map(pos => pos.__packedPos)) : undefined);
-    return new ClockworkMultiroomDistanceMap(result);
+    const result = js_bfs_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxOps, maxRooms, maxPathCost, anyOfDestinations
+        ? new Uint32Array(anyOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined, allOfDestinations
+        ? new Uint32Array(allOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined);
+    return fromPackedSearchResult(result);
 }
 
 /**
@@ -1897,8 +1997,18 @@ function dijkstraMultiroomDistanceMap(start, { costMatrixCallback, maxOps = MAX_
         throw new Error('At least one of maxOps, maxRooms, maxPathCost, anyOfDestinations, or allOfDestinations must be set');
     }
     const startPacked = new Uint32Array(start.map(pos => pos.__packedPos));
-    const result = js_dijkstra_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxOps, maxRooms, maxPathCost, anyOfDestinations ? new Uint32Array(anyOfDestinations.map(pos => pos.__packedPos)) : undefined, allOfDestinations ? new Uint32Array(allOfDestinations.map(pos => pos.__packedPos)) : undefined);
-    return new ClockworkMultiroomDistanceMap(result);
+    const result = js_dijkstra_multiroom_distance_map(startPacked, (room) => costMatrixCallback(fromPackedRoomName(room)), maxOps, maxRooms, maxPathCost, anyOfDestinations
+        ? new Uint32Array(anyOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined, allOfDestinations
+        ? new Uint32Array(allOfDestinations.reduce((acc, { pos, range }) => {
+            acc.push(pos.__packedPos, range);
+            return acc;
+        }, []))
+        : undefined);
+    return fromPackedSearchResult(result);
 }
 
 /**