@supalosa/chronodivide-bot 0.5.3 → 0.6.4

package/dist/bot/logic/map/sector.js

@@ -1,138 +1,138 @@
-// A sector is a uniform-sized segment of the map.
-import { Vector2 } from "@chronodivide/game-api";
-import { calculateAreaVisibility } from "./map.js";
-export const SECTOR_SIZE = 8;
-export class Sector {
-    constructor(sectorStartPoint, sectorStartTile, sectorVisibilityPct, sectorVisibilityLastCheckTick) {
-        this.sectorStartPoint = sectorStartPoint;
-        this.sectorStartTile = sectorStartTile;
-        this.sectorVisibilityPct = sectorVisibilityPct;
-        this.sectorVisibilityLastCheckTick = sectorVisibilityLastCheckTick;
-        this.sectorExploreAttempts = 0;
-    }
-    onExploreAttempted(currentTick) {
-        this.sectorExploreAttempts++;
-        this.sectorLastExploredAt = currentTick;
-    }
-    // Whether we should attempt to explore this sector, given the cooldown and limit of attempts.
-    shouldAttemptExploration(currentTick, cooldown, limit) {
-        if (limit >= this.sectorExploreAttempts) {
-            return false;
-        }
-        if (this.sectorLastExploredAt && currentTick < this.sectorLastExploredAt + cooldown) {
-            return false;
-        }
-        return true;
-    }
-}
-export class SectorCache {
-    constructor(mapApi, mapBounds) {
-        this.sectors = [];
-        this.mapBounds = mapBounds;
-        this.sectorsX = Math.ceil(mapBounds.width / SECTOR_SIZE);
-        this.sectorsY = Math.ceil(mapBounds.height / SECTOR_SIZE);
-        this.sectors = new Array(this.sectorsX);
-        for (let xx = 0; xx < this.sectorsX; ++xx) {
-            this.sectors[xx] = new Array(this.sectorsY);
-            for (let yy = 0; yy < this.sectorsY; ++yy) {
-                const tileX = xx * SECTOR_SIZE;
-                const tileY = yy * SECTOR_SIZE;
-                this.sectors[xx][yy] = new Sector(new Vector2(tileX, tileY), mapApi.getTile(tileX, tileY), undefined, undefined);
-            }
-        }
-    }
-    getMapBounds() {
-        return this.mapBounds;
-    }
-    updateSectors(currentGameTick, maxSectorsToUpdate, mapApi, playerData) {
-        let nextSectorX = this.lastUpdatedSectorX ? this.lastUpdatedSectorX + 1 : 0;
-        let nextSectorY = this.lastUpdatedSectorY ? this.lastUpdatedSectorY : 0;
-        let updatedThisCycle = 0;
-        while (updatedThisCycle < maxSectorsToUpdate) {
-            if (nextSectorX >= this.sectorsX) {
-                nextSectorX = 0;
-                ++nextSectorY;
-            }
-            if (nextSectorY >= this.sectorsY) {
-                nextSectorY = 0;
-                nextSectorX = 0;
-            }
-            let sector = this.getSector(nextSectorX, nextSectorY);
-            if (sector) {
-                sector.sectorVisibilityLastCheckTick = currentGameTick;
-                let sp = sector.sectorStartPoint;
-                let ep = new Vector2(sp.x + SECTOR_SIZE, sp.y + SECTOR_SIZE);
-                let visibility = calculateAreaVisibility(mapApi, playerData, sp, ep);
-                if (visibility.validTiles > 0) {
-                    sector.sectorVisibilityPct = visibility.visibleTiles / visibility.validTiles;
-                }
-                else {
-                    sector.sectorVisibilityPct = undefined;
-                }
-            }
-            this.lastUpdatedSectorX = nextSectorX;
-            this.lastUpdatedSectorY = nextSectorY;
-            ++nextSectorX;
-            ++updatedThisCycle;
-        }
-    }
-    // Return % of sectors that are updated.
-    getSectorUpdateRatio(sectorsUpdatedSinceGameTick) {
-        let updated = 0, total = 0;
-        for (let xx = 0; xx < this.sectorsX; ++xx) {
-            for (let yy = 0; yy < this.sectorsY; ++yy) {
-                let sector = this.sectors[xx][yy];
-                if (sector &&
-                    sector.sectorVisibilityLastCheckTick &&
-                    sector.sectorVisibilityLastCheckTick >= sectorsUpdatedSinceGameTick) {
-                    ++updated;
-                }
-                ++total;
-            }
-        }
-        return updated / total;
-    }
-    /**
-     * Return the ratio (0-1) of tiles that are visible. Returns undefined if we haven't scanned the whole map yet.
-     */
-    getOverallVisibility() {
-        let visible = 0, total = 0;
-        for (let xx = 0; xx < this.sectorsX; ++xx) {
-            for (let yy = 0; yy < this.sectorsY; ++yy) {
-                let sector = this.sectors[xx][yy];
-                // Undefined visibility.
-                if (sector.sectorVisibilityPct != undefined) {
-                    visible += sector.sectorVisibilityPct;
-                    total += 1.0;
-                }
-            }
-        }
-        return visible / total;
-    }
-    getSector(sectorX, sectorY) {
-        if (sectorX < 0 || sectorX >= this.sectorsX || sectorY < 0 || sectorY >= this.sectorsY) {
-            return undefined;
-        }
-        return this.sectors[sectorX][sectorY];
-    }
-    getSectorBounds() {
-        return { width: this.sectorsX, height: this.sectorsY };
-    }
-    getSectorCoordinatesForWorldPosition(x, y) {
-        if (x < 0 || x >= this.mapBounds.width || y < 0 || y >= this.mapBounds.height) {
-            return undefined;
-        }
-        return {
-            sectorX: Math.floor(x / SECTOR_SIZE),
-            sectorY: Math.floor(y / SECTOR_SIZE),
-        };
-    }
-    getSectorForWorldPosition(x, y) {
-        const sectorCoordinates = this.getSectorCoordinatesForWorldPosition(x, y);
-        if (!sectorCoordinates) {
-            return undefined;
-        }
-        return this.sectors[Math.floor(x / SECTOR_SIZE)][Math.floor(y / SECTOR_SIZE)];
-    }
-}
+// A sector is a uniform-sized segment of the map.
+import { Vector2 } from "@chronodivide/game-api";
+import { calculateAreaVisibility } from "./map.js";
+export const SECTOR_SIZE = 8;
+export class Sector {
+    constructor(sectorStartPoint, sectorStartTile, sectorVisibilityPct, sectorVisibilityLastCheckTick) {
+        this.sectorStartPoint = sectorStartPoint;
+        this.sectorStartTile = sectorStartTile;
+        this.sectorVisibilityPct = sectorVisibilityPct;
+        this.sectorVisibilityLastCheckTick = sectorVisibilityLastCheckTick;
+        this.sectorExploreAttempts = 0;
+    }
+    onExploreAttempted(currentTick) {
+        this.sectorExploreAttempts++;
+        this.sectorLastExploredAt = currentTick;
+    }
+    // Whether we should attempt to explore this sector, given the cooldown and limit of attempts.
+    shouldAttemptExploration(currentTick, cooldown, limit) {
+        if (limit >= this.sectorExploreAttempts) {
+            return false;
+        }
+        if (this.sectorLastExploredAt && currentTick < this.sectorLastExploredAt + cooldown) {
+            return false;
+        }
+        return true;
+    }
+}
+export class SectorCache {
+    constructor(mapApi, mapBounds) {
+        this.sectors = [];
+        this.mapBounds = mapBounds;
+        this.sectorsX = Math.ceil(mapBounds.width / SECTOR_SIZE);
+        this.sectorsY = Math.ceil(mapBounds.height / SECTOR_SIZE);
+        this.sectors = new Array(this.sectorsX);
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            this.sectors[xx] = new Array(this.sectorsY);
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                const tileX = xx * SECTOR_SIZE;
+                const tileY = yy * SECTOR_SIZE;
+                this.sectors[xx][yy] = new Sector(new Vector2(tileX, tileY), mapApi.getTile(tileX, tileY), undefined, undefined);
+            }
+        }
+    }
+    getMapBounds() {
+        return this.mapBounds;
+    }
+    updateSectors(currentGameTick, maxSectorsToUpdate, mapApi, playerData) {
+        let nextSectorX = this.lastUpdatedSectorX ? this.lastUpdatedSectorX + 1 : 0;
+        let nextSectorY = this.lastUpdatedSectorY ? this.lastUpdatedSectorY : 0;
+        let updatedThisCycle = 0;
+        while (updatedThisCycle < maxSectorsToUpdate) {
+            if (nextSectorX >= this.sectorsX) {
+                nextSectorX = 0;
+                ++nextSectorY;
+            }
+            if (nextSectorY >= this.sectorsY) {
+                nextSectorY = 0;
+                nextSectorX = 0;
+            }
+            let sector = this.getSector(nextSectorX, nextSectorY);
+            if (sector) {
+                sector.sectorVisibilityLastCheckTick = currentGameTick;
+                let sp = sector.sectorStartPoint;
+                let ep = new Vector2(sp.x + SECTOR_SIZE, sp.y + SECTOR_SIZE);
+                let visibility = calculateAreaVisibility(mapApi, playerData, sp, ep);
+                if (visibility.validTiles > 0) {
+                    sector.sectorVisibilityPct = visibility.visibleTiles / visibility.validTiles;
+                }
+                else {
+                    sector.sectorVisibilityPct = undefined;
+                }
+            }
+            this.lastUpdatedSectorX = nextSectorX;
+            this.lastUpdatedSectorY = nextSectorY;
+            ++nextSectorX;
+            ++updatedThisCycle;
+        }
+    }
+    // Return % of sectors that are updated.
+    getSectorUpdateRatio(sectorsUpdatedSinceGameTick) {
+        let updated = 0, total = 0;
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                let sector = this.sectors[xx][yy];
+                if (sector &&
+                    sector.sectorVisibilityLastCheckTick &&
+                    sector.sectorVisibilityLastCheckTick >= sectorsUpdatedSinceGameTick) {
+                    ++updated;
+                }
+                ++total;
+            }
+        }
+        return updated / total;
+    }
+    /**
+     * Return the ratio (0-1) of tiles that are visible. Returns undefined if we haven't scanned the whole map yet.
+     */
+    getOverallVisibility() {
+        let visible = 0, total = 0;
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                let sector = this.sectors[xx][yy];
+                // Undefined visibility.
+                if (sector.sectorVisibilityPct != undefined) {
+                    visible += sector.sectorVisibilityPct;
+                    total += 1.0;
+                }
+            }
+        }
+        return visible / total;
+    }
+    getSector(sectorX, sectorY) {
+        if (sectorX < 0 || sectorX >= this.sectorsX || sectorY < 0 || sectorY >= this.sectorsY) {
+            return undefined;
+        }
+        return this.sectors[sectorX][sectorY];
+    }
+    getSectorBounds() {
+        return { width: this.sectorsX, height: this.sectorsY };
+    }
+    getSectorCoordinatesForWorldPosition(x, y) {
+        if (x < 0 || x >= this.mapBounds.width || y < 0 || y >= this.mapBounds.height) {
+            return undefined;
+        }
+        return {
+            sectorX: Math.floor(x / SECTOR_SIZE),
+            sectorY: Math.floor(y / SECTOR_SIZE),
+        };
+    }
+    getSectorForWorldPosition(x, y) {
+        const sectorCoordinates = this.getSectorCoordinatesForWorldPosition(x, y);
+        if (!sectorCoordinates) {
+            return undefined;
+        }
+        return this.sectors[Math.floor(x / SECTOR_SIZE)][Math.floor(y / SECTOR_SIZE)];
+    }
+}
 //# sourceMappingURL=sector.js.map

package/dist/bot/logic/mission/actionBatcher.js

@@ -1,92 +1,92 @@
-// Used to group related actions together to minimise actionApi calls. For example, if multiple units
-import { Vector2 } from "@chronodivide/game-api";
-import { groupBy } from "../common/utils.js";
-// are ordered to move to the same location, all of them will be ordered to move in a single action.
-export class BatchableAction {
-    constructor(_unitId, _orderType, _point, _targetId, 
-    // If you don't want this action to be swallowed by dedupe, provide a unique nonce
-    _nonce = 0) {
-        this._unitId = _unitId;
-        this._orderType = _orderType;
-        this._point = _point;
-        this._targetId = _targetId;
-        this._nonce = _nonce;
-    }
-    static noTarget(unitId, orderType, nonce = 0) {
-        return new BatchableAction(unitId, orderType, undefined, undefined, nonce);
-    }
-    static toPoint(unitId, orderType, point, nonce = 0) {
-        return new BatchableAction(unitId, orderType, point, undefined);
-    }
-    static toTargetId(unitId, orderType, targetId, nonce = 0) {
-        return new BatchableAction(unitId, orderType, undefined, targetId, nonce);
-    }
-    get unitId() {
-        return this._unitId;
-    }
-    get orderType() {
-        return this._orderType;
-    }
-    get point() {
-        return this._point;
-    }
-    get targetId() {
-        return this._targetId;
-    }
-    isSameAs(other) {
-        if (this._unitId !== other._unitId) {
-            return false;
-        }
-        if (this._orderType !== other._orderType) {
-            return false;
-        }
-        if (this._point !== other._point) {
-            return false;
-        }
-        if (this._targetId !== other._targetId) {
-            return false;
-        }
-        if (this._nonce !== other._nonce) {
-            return false;
-        }
-        return true;
-    }
-}
-export class ActionBatcher {
-    constructor() {
-        this.actions = [];
-    }
-    push(action) {
-        this.actions.push(action);
-    }
-    resolve(actionsApi) {
-        const groupedCommands = groupBy(this.actions, (action) => action.orderType.valueOf().toString());
-        const vectorToStr = (v) => v.x + "," + v.y;
-        const strToVector = (str) => {
-            const [x, y] = str.split(",");
-            return new Vector2(parseInt(x), parseInt(y));
-        };
-        // Group by command type.
-        Object.entries(groupedCommands).forEach(([commandValue, commands]) => {
-            // i hate this
-            const commandType = parseInt(commandValue);
-            // Group by command target ID.
-            const byTarget = groupBy(commands.filter((command) => !!command.targetId), (command) => command.targetId?.toString());
-            Object.entries(byTarget).forEach(([targetId, unitCommands]) => {
-                actionsApi.orderUnits(unitCommands.map((command) => command.unitId), commandType, parseInt(targetId));
-            });
-            // Group by position (the vector is encoded as a string of the form "x,y")
-            const byPosition = groupBy(commands.filter((command) => !!command.point), (command) => vectorToStr(command.point));
-            Object.entries(byPosition).forEach(([point, unitCommands]) => {
-                const vector = strToVector(point);
-                actionsApi.orderUnits(unitCommands.map((command) => command.unitId), commandType, vector.x, vector.y);
-            });
-            // Actions with no targets
-            const noTargets = commands.filter((command) => !command.targetId && !command.point);
-            if (noTargets.length > 0) {
-                actionsApi.orderUnits(noTargets.map((action) => action.unitId), commandType);
-            }
-        });
-    }
-}
+// Used to group related actions together to minimise actionApi calls. For example, if multiple units
+import { Vector2 } from "@chronodivide/game-api";
+import { groupBy } from "../common/utils.js";
+// are ordered to move to the same location, all of them will be ordered to move in a single action.
+export class BatchableAction {
+    constructor(_unitId, _orderType, _point, _targetId, 
+    // If you don't want this action to be swallowed by dedupe, provide a unique nonce
+    _nonce = 0) {
+        this._unitId = _unitId;
+        this._orderType = _orderType;
+        this._point = _point;
+        this._targetId = _targetId;
+        this._nonce = _nonce;
+    }
+    static noTarget(unitId, orderType, nonce = 0) {
+        return new BatchableAction(unitId, orderType, undefined, undefined, nonce);
+    }
+    static toPoint(unitId, orderType, point, nonce = 0) {
+        return new BatchableAction(unitId, orderType, point, undefined);
+    }
+    static toTargetId(unitId, orderType, targetId, nonce = 0) {
+        return new BatchableAction(unitId, orderType, undefined, targetId, nonce);
+    }
+    get unitId() {
+        return this._unitId;
+    }
+    get orderType() {
+        return this._orderType;
+    }
+    get point() {
+        return this._point;
+    }
+    get targetId() {
+        return this._targetId;
+    }
+    isSameAs(other) {
+        if (this._unitId !== other._unitId) {
+            return false;
+        }
+        if (this._orderType !== other._orderType) {
+            return false;
+        }
+        if (this._point !== other._point) {
+            return false;
+        }
+        if (this._targetId !== other._targetId) {
+            return false;
+        }
+        if (this._nonce !== other._nonce) {
+            return false;
+        }
+        return true;
+    }
+}
+export class ActionBatcher {
+    constructor() {
+        this.actions = [];
+    }
+    push(action) {
+        this.actions.push(action);
+    }
+    resolve(actionsApi) {
+        const groupedCommands = groupBy(this.actions, (action) => action.orderType.valueOf().toString());
+        const vectorToStr = (v) => v.x + "," + v.y;
+        const strToVector = (str) => {
+            const [x, y] = str.split(",");
+            return new Vector2(parseInt(x), parseInt(y));
+        };
+        // Group by command type.
+        Object.entries(groupedCommands).forEach(([commandValue, commands]) => {
+            // i hate this
+            const commandType = parseInt(commandValue);
+            // Group by command target ID.
+            const byTarget = groupBy(commands.filter((command) => !!command.targetId), (command) => command.targetId?.toString());
+            Object.entries(byTarget).forEach(([targetId, unitCommands]) => {
+                actionsApi.orderUnits(unitCommands.map((command) => command.unitId), commandType, parseInt(targetId));
+            });
+            // Group by position (the vector is encoded as a string of the form "x,y")
+            const byPosition = groupBy(commands.filter((command) => !!command.point), (command) => vectorToStr(command.point));
+            Object.entries(byPosition).forEach(([point, unitCommands]) => {
+                const vector = strToVector(point);
+                actionsApi.orderUnits(unitCommands.map((command) => command.unitId), commandType, vector.x, vector.y);
+            });
+            // Actions with no targets
+            const noTargets = commands.filter((command) => !command.targetId && !command.point);
+            if (noTargets.length > 0) {
+                actionsApi.orderUnits(noTargets.map((action) => action.unitId), commandType);
+            }
+        });
+    }
+}
 //# sourceMappingURL=actionBatcher.js.map