@supalosa/chronodivide-bot 0.5.4 → 0.6.4

package/src/bot/logic/map/sector.ts

@@ -1,174 +1,174 @@
-// A sector is a uniform-sized segment of the map.
-
-import { MapApi, PlayerData, Size, Tile, Vector2 } from "@chronodivide/game-api";
-import { calculateAreaVisibility } from "./map.js";
-
-export const SECTOR_SIZE = 8;
-
-export class Sector {
-    // How many times we've attempted to enter the sector.
-    private sectorExploreAttempts: number;
-    private sectorLastExploredAt: number | undefined;
-
-    constructor(
-        public sectorStartPoint: Vector2,
-        public sectorStartTile: Tile | undefined,
-        public sectorVisibilityPct: number | undefined,
-        public sectorVisibilityLastCheckTick: number | undefined,
-    ) {
-        this.sectorExploreAttempts = 0;
-    }
-
-    public onExploreAttempted(currentTick: number) {
-        this.sectorExploreAttempts++;
-        this.sectorLastExploredAt = currentTick;
-    }
-
-    // Whether we should attempt to explore this sector, given the cooldown and limit of attempts.
-    public shouldAttemptExploration(currentTick: number, cooldown: number, limit: number) {
-        if (limit >= this.sectorExploreAttempts) {
-            return false;
-        }
-
-        if (this.sectorLastExploredAt && currentTick < this.sectorLastExploredAt + cooldown) {
-            return false;
-        }
-
-        return true;
-    }
-}
-
-export class SectorCache {
-    private sectors: Sector[][] = [];
-    private mapBounds: Size;
-    private sectorsX: number;
-    private sectorsY: number;
-    private lastUpdatedSectorX: number | undefined;
-    private lastUpdatedSectorY: number | undefined;
-
-    constructor(mapApi: MapApi, mapBounds: Size) {
-        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,
-                );
-            }
-        }
-    }
-
-    public getMapBounds(): Size {
-        return this.mapBounds;
-    }
-
-    public updateSectors(currentGameTick: number, maxSectorsToUpdate: number, mapApi: MapApi, playerData: 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: Sector | undefined = 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.
-    public getSectorUpdateRatio(sectorsUpdatedSinceGameTick: number): number {
-        let updated = 0,
-            total = 0;
-        for (let xx = 0; xx < this.sectorsX; ++xx) {
-            for (let yy = 0; yy < this.sectorsY; ++yy) {
-                let sector: 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.
-     */
-    public getOverallVisibility(): number | undefined {
-        let visible = 0,
-            total = 0;
-        for (let xx = 0; xx < this.sectorsX; ++xx) {
-            for (let yy = 0; yy < this.sectorsY; ++yy) {
-                let sector: Sector = this.sectors[xx][yy];
-
-                // Undefined visibility.
-                if (sector.sectorVisibilityPct != undefined) {
-                    visible += sector.sectorVisibilityPct;
-                    total += 1.0;
-                }
-            }
-        }
-        return visible / total;
-    }
-
-    public getSector(sectorX: number, sectorY: number): Sector | undefined {
-        if (sectorX < 0 || sectorX >= this.sectorsX || sectorY < 0 || sectorY >= this.sectorsY) {
-            return undefined;
-        }
-        return this.sectors[sectorX][sectorY];
-    }
-
-    public getSectorBounds(): Size {
-        return { width: this.sectorsX, height: this.sectorsY };
-    }
-
-    public getSectorCoordinatesForWorldPosition(x: number, y: number) {
-        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),
-        };
-    }
-
-    public getSectorForWorldPosition(x: number, y: number): Sector | undefined {
-        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 { MapApi, PlayerData, Size, Tile, Vector2 } from "@chronodivide/game-api";
+import { calculateAreaVisibility } from "./map.js";
+
+export const SECTOR_SIZE = 8;
+
+export class Sector {
+    // How many times we've attempted to enter the sector.
+    private sectorExploreAttempts: number;
+    private sectorLastExploredAt: number | undefined;
+
+    constructor(
+        public sectorStartPoint: Vector2,
+        public sectorStartTile: Tile | undefined,
+        public sectorVisibilityPct: number | undefined,
+        public sectorVisibilityLastCheckTick: number | undefined,
+    ) {
+        this.sectorExploreAttempts = 0;
+    }
+
+    public onExploreAttempted(currentTick: number) {
+        this.sectorExploreAttempts++;
+        this.sectorLastExploredAt = currentTick;
+    }
+
+    // Whether we should attempt to explore this sector, given the cooldown and limit of attempts.
+    public shouldAttemptExploration(currentTick: number, cooldown: number, limit: number) {
+        if (limit >= this.sectorExploreAttempts) {
+            return false;
+        }
+
+        if (this.sectorLastExploredAt && currentTick < this.sectorLastExploredAt + cooldown) {
+            return false;
+        }
+
+        return true;
+    }
+}
+
+export class SectorCache {
+    private sectors: Sector[][] = [];
+    private mapBounds: Size;
+    private sectorsX: number;
+    private sectorsY: number;
+    private lastUpdatedSectorX: number | undefined;
+    private lastUpdatedSectorY: number | undefined;
+
+    constructor(mapApi: MapApi, mapBounds: Size) {
+        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,
+                );
+            }
+        }
+    }
+
+    public getMapBounds(): Size {
+        return this.mapBounds;
+    }
+
+    public updateSectors(currentGameTick: number, maxSectorsToUpdate: number, mapApi: MapApi, playerData: 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: Sector | undefined = 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.
+    public getSectorUpdateRatio(sectorsUpdatedSinceGameTick: number): number {
+        let updated = 0,
+            total = 0;
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                let sector: 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.
+     */
+    public getOverallVisibility(): number | undefined {
+        let visible = 0,
+            total = 0;
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                let sector: Sector = this.sectors[xx][yy];
+
+                // Undefined visibility.
+                if (sector.sectorVisibilityPct != undefined) {
+                    visible += sector.sectorVisibilityPct;
+                    total += 1.0;
+                }
+            }
+        }
+        return visible / total;
+    }
+
+    public getSector(sectorX: number, sectorY: number): Sector | undefined {
+        if (sectorX < 0 || sectorX >= this.sectorsX || sectorY < 0 || sectorY >= this.sectorsY) {
+            return undefined;
+        }
+        return this.sectors[sectorX][sectorY];
+    }
+
+    public getSectorBounds(): Size {
+        return { width: this.sectorsX, height: this.sectorsY };
+    }
+
+    public getSectorCoordinatesForWorldPosition(x: number, y: number) {
+        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),
+        };
+    }
+
+    public getSectorForWorldPosition(x: number, y: number): Sector | undefined {
+        const sectorCoordinates = this.getSectorCoordinatesForWorldPosition(x, y);
+        if (!sectorCoordinates) {
+            return undefined;
+        }
+        return this.sectors[Math.floor(x / SECTOR_SIZE)][Math.floor(y / SECTOR_SIZE)];
+    }
+}

package/src/bot/logic/mission/actionBatcher.ts

@@ -1,124 +1,124 @@
-// Used to group related actions together to minimise actionApi calls. For example, if multiple units
-
-import { ActionsApi, OrderType, 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 {
-    private constructor(
-        private _unitId: number,
-        private _orderType: OrderType,
-        private _point?: Vector2,
-        private _targetId?: number,
-        // If you don't want this action to be swallowed by dedupe, provide a unique nonce
-        private _nonce: number = 0,
-    ) {}
-
-    static noTarget(unitId: number, orderType: OrderType, nonce: number = 0) {
-        return new BatchableAction(unitId, orderType, undefined, undefined, nonce);
-    }
-
-    static toPoint(unitId: number, orderType: OrderType, point: Vector2, nonce: number = 0) {
-        return new BatchableAction(unitId, orderType, point, undefined);
-    }
-
-    static toTargetId(unitId: number, orderType: OrderType, targetId: number, nonce: number = 0) {
-        return new BatchableAction(unitId, orderType, undefined, targetId, nonce);
-    }
-
-    public get unitId() {
-        return this._unitId;
-    }
-
-    public get orderType() {
-        return this._orderType;
-    }
-
-    public get point() {
-        return this._point;
-    }
-
-    public get targetId() {
-        return this._targetId;
-    }
-
-    public isSameAs(other: BatchableAction) {
-        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 {
-    private actions: BatchableAction[];
-
-    constructor() {
-        this.actions = [];
-    }
-
-    push(action: BatchableAction) {
-        this.actions.push(action);
-    }
-
-    resolve(actionsApi: ActionsApi) {
-        const groupedCommands = groupBy(this.actions, (action) => action.orderType.valueOf().toString());
-        const vectorToStr = (v: Vector2) => v.x + "," + v.y;
-        const strToVector = (str: string) => {
-            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: OrderType = parseInt(commandValue) as OrderType;
-            // 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 { ActionsApi, OrderType, 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 {
+    private constructor(
+        private _unitId: number,
+        private _orderType: OrderType,
+        private _point?: Vector2,
+        private _targetId?: number,
+        // If you don't want this action to be swallowed by dedupe, provide a unique nonce
+        private _nonce: number = 0,
+    ) {}
+
+    static noTarget(unitId: number, orderType: OrderType, nonce: number = 0) {
+        return new BatchableAction(unitId, orderType, undefined, undefined, nonce);
+    }
+
+    static toPoint(unitId: number, orderType: OrderType, point: Vector2, nonce: number = 0) {
+        return new BatchableAction(unitId, orderType, point, undefined);
+    }
+
+    static toTargetId(unitId: number, orderType: OrderType, targetId: number, nonce: number = 0) {
+        return new BatchableAction(unitId, orderType, undefined, targetId, nonce);
+    }
+
+    public get unitId() {
+        return this._unitId;
+    }
+
+    public get orderType() {
+        return this._orderType;
+    }
+
+    public get point() {
+        return this._point;
+    }
+
+    public get targetId() {
+        return this._targetId;
+    }
+
+    public isSameAs(other: BatchableAction) {
+        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 {
+    private actions: BatchableAction[];
+
+    constructor() {
+        this.actions = [];
+    }
+
+    push(action: BatchableAction) {
+        this.actions.push(action);
+    }
+
+    resolve(actionsApi: ActionsApi) {
+        const groupedCommands = groupBy(this.actions, (action) => action.orderType.valueOf().toString());
+        const vectorToStr = (v: Vector2) => v.x + "," + v.y;
+        const strToVector = (str: string) => {
+            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: OrderType = parseInt(commandValue) as OrderType;
+            // 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,
+                );
+            }
+        });
+    }
+}