@supalosa/chronodivide-bot 0.2.1 → 0.2.2

package/src/bot/logic/building/resourceCollectionBuilding.ts

@@ -1,56 +1,56 @@
-import { GameApi, PlayerData, Point2D, TechnoRules, Tile } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
-import { BasicBuilding } from "./basicBuilding.js";
-import {
-    AiBuildingRules,
-    getDefaultPlacementLocation,
-    numBuildingsOwnedOfName,
-    numBuildingsOwnedOfType,
-} from "./building.js";
-
-export class ResourceCollectionBuilding extends BasicBuilding {
-    constructor(basePriority: number, maxNeeded: number, onlyBuildWhenFloatingCreditsAmount?: number) {
-        super(basePriority, maxNeeded, onlyBuildWhenFloatingCreditsAmount);
-    }
-
-    getPlacementLocation(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules
-    ): { rx: number; ry: number } | undefined {
-        // Prefer spawning close to ore.
-        let selectedLocation = playerData.startLocation;
-
-        var closeOre: Tile | undefined;
-        var closeOreDist: number | undefined;
-        let allTileResourceData = game.mapApi.getAllTilesResourceData();
-        for (let i = 0; i < allTileResourceData.length; ++i) {
-            let tileResourceData = allTileResourceData[i];
-            if (tileResourceData.spawnsOre) {
-                let dist = Math.sqrt(
-                    (selectedLocation.x - tileResourceData.tile.rx) ** 2 +
-                        (selectedLocation.y - tileResourceData.tile.ry) ** 2
-                );
-                if (closeOreDist == undefined || dist < closeOreDist) {
-                    closeOreDist = dist;
-                    closeOre = tileResourceData.tile;
-                }
-            }
-        }
-        if (closeOre) {
-            selectedLocation = { x: closeOre.rx, y: closeOre.ry };
-        }
-        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules);
-    }
-
-    // Don't build/start selling these if we don't have any harvesters
-    getMaxCount(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number | null {
-        const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
-        return Math.max(1, harvesters * 2);
-    }
-}
+import { GameApi, PlayerData, Point2D, TechnoRules, Tile } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { BasicBuilding } from "./basicBuilding.js";
+import {
+    AiBuildingRules,
+    getDefaultPlacementLocation,
+    numBuildingsOwnedOfName,
+    numBuildingsOwnedOfType,
+} from "./building.js";
+
+export class ResourceCollectionBuilding extends BasicBuilding {
+    constructor(basePriority: number, maxNeeded: number, onlyBuildWhenFloatingCreditsAmount?: number) {
+        super(basePriority, maxNeeded, onlyBuildWhenFloatingCreditsAmount);
+    }
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules
+    ): { rx: number; ry: number } | undefined {
+        // Prefer spawning close to ore.
+        let selectedLocation = playerData.startLocation;
+
+        var closeOre: Tile | undefined;
+        var closeOreDist: number | undefined;
+        let allTileResourceData = game.mapApi.getAllTilesResourceData();
+        for (let i = 0; i < allTileResourceData.length; ++i) {
+            let tileResourceData = allTileResourceData[i];
+            if (tileResourceData.spawnsOre) {
+                let dist = Math.sqrt(
+                    (selectedLocation.x - tileResourceData.tile.rx) ** 2 +
+                        (selectedLocation.y - tileResourceData.tile.ry) ** 2
+                );
+                if (closeOreDist == undefined || dist < closeOreDist) {
+                    closeOreDist = dist;
+                    closeOre = tileResourceData.tile;
+                }
+            }
+        }
+        if (closeOre) {
+            selectedLocation = { x: closeOre.rx, y: closeOre.ry };
+        }
+        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules);
+    }
+
+    // Don't build/start selling these if we don't have any harvesters
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number | null {
+        const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
+        return Math.max(1, harvesters * 2);
+    }
+}

package/src/bot/logic/common/scout.ts

@@ -1,4 +1,7 @@
-import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { GameApi, PlayerData, Point2D } from "@chronodivide/game-api";
+import { Sector, SectorCache } from "../map/sector";
+import { DebugLogger } from "./utils";
+import { PriorityQueue } from "@datastructures-js/priority-queue";
 
 export const getUnseenStartingLocations = (gameApi: GameApi, playerData: PlayerData) => {
     const unseenStartingLocations = gameApi.mapApi.getStartingLocations().filter((startingLocation) => {
@@ -10,3 +13,126 @@ export const getUnseenStartingLocations = (gameApi: GameApi, playerData: PlayerD
     });
     return unseenStartingLocations;
 };
+
+class PrioritisedScoutTarget {
+    private _targetPoint2D?: Point2D;
+    private _targetSector?: Sector;
+    private _priority: number;
+
+    constructor(priority: number, target: Point2D | Sector) {
+        if (target.hasOwnProperty("x") && target.hasOwnProperty("y")) {
+            this._targetPoint2D = target as Point2D;
+        } else if (target.hasOwnProperty("sectorStartPoint")) {
+            this._targetSector = target as Sector;
+        } else {
+            throw new TypeError(`invalid object passed as target: ${target}`);
+        }
+        this._priority = priority;
+    }
+
+    get priority() {
+        return this._priority;
+    }
+
+    asPoint2D() {
+        return this._targetPoint2D ?? this._targetSector?.sectorStartPoint ?? null;
+    }
+
+    get targetSector() {
+        return this._targetSector;
+    }
+}
+
+const ENEMY_SPAWN_POINT_PRIORITY = 100;
+
+// Amount of sectors around the starting sector to try to scout.
+const NEARBY_SECTOR_RADIUS = 2;
+const NEARBY_SECTOR_BASE_PRIORITY = 1000;
+
+export class ScoutingManager {
+    private scoutingQueue: PriorityQueue<PrioritisedScoutTarget>;
+
+    constructor(private logger: DebugLogger) {
+        // Order by descending priority.
+        this.scoutingQueue = new PriorityQueue((a: PrioritisedScoutTarget, b: PrioritisedScoutTarget) => b.priority - a.priority);
+    }
+
+    onGameStart(gameApi: GameApi, playerData: PlayerData, sectorCache: SectorCache) {
+        // Queue hostile starting locations with high priority.
+        gameApi.mapApi
+            .getStartingLocations()
+            .filter((startingLocation) => {
+                if (startingLocation == playerData.startLocation) {
+                    return false;
+                }
+                let tile = gameApi.mapApi.getTile(startingLocation.x, startingLocation.y);
+                return tile ? !gameApi.mapApi.isVisibleTile(tile, playerData.name) : false;
+            })
+            .map((tile) => new PrioritisedScoutTarget(ENEMY_SPAWN_POINT_PRIORITY, tile))
+            .forEach((target) => {
+                this.logger(`Adding ${target.asPoint2D()?.x},${target.asPoint2D()?.y} to initial scouting queue`);
+                this.scoutingQueue.enqueue(target);
+            });
+
+        // Queue nearby sectors.
+        const { x: startX, y: startY } = playerData.startLocation;
+        const { x: sectorsX, y: sectorsY } = sectorCache.getSectorBounds();
+        const startingSector = sectorCache.getSectorCoordinatesForWorldPosition(startX, startY);
+
+        if (!startingSector) {
+            return;
+        }
+
+        for (
+            let x: number = Math.max(0, startingSector.sectorX - NEARBY_SECTOR_RADIUS);
+            x <= Math.min(sectorsX, startingSector.sectorX + NEARBY_SECTOR_RADIUS);
+            ++x
+        ) {
+            for (
+                let y: number = Math.max(0, startingSector.sectorY - NEARBY_SECTOR_RADIUS);
+                y <= Math.min(sectorsY, startingSector.sectorY + NEARBY_SECTOR_RADIUS);
+                ++y
+            ) {
+                if (x === startingSector?.sectorX && y === startingSector?.sectorY) {
+                    continue;
+                }
+                // Make it scout closer sectors first.
+                const distanceFactor = Math.pow(x - startingSector.sectorX, 2) + Math.pow(y - startingSector.sectorY, 2);
+                const sector = sectorCache.getSector(x, y);
+                if (sector) {
+                    const maybeTarget = new PrioritisedScoutTarget(NEARBY_SECTOR_BASE_PRIORITY - distanceFactor, sector);
+                    const maybePoint = maybeTarget.asPoint2D();
+                    if (maybePoint && gameApi.mapApi.getTile(maybePoint.x, maybePoint.y)) {
+                        this.scoutingQueue.enqueue(maybeTarget);
+                    }
+                }
+            }
+        }
+    }
+
+    onAiUpdate(gameApi: GameApi, playerData: PlayerData) {
+        const currentHead = this.scoutingQueue.front();
+        if (!currentHead) {
+            return;
+        }
+        const head = currentHead.asPoint2D();
+        if (!head) {
+            this.scoutingQueue.dequeue();
+            return;
+        }
+        const { x, y } = head;
+        const tile = gameApi.mapApi.getTile(x, y);
+        if (tile && gameApi.mapApi.isVisibleTile(tile, playerData.name)) {
+            this.logger(`head point is visible, dequeueing`);
+            this.scoutingQueue.dequeue();
+        }
+    }
+
+    getNewScoutTarget() {
+        return this.scoutingQueue.dequeue();
+    }
+
+    hasScoutTargets() {
+        return !this.scoutingQueue.isEmpty();
+    }
+}

package/src/bot/logic/common/utils.ts

@@ -0,0 +1 @@
+export type DebugLogger = (message: string, sayInGame?: boolean) => void;

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

@@ -1,84 +1,70 @@
-import { GameApi, MapApi, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
-
-// Expensive one-time call to determine the size of the map.
-// The result is a point just outside the bounds of the map.
-export function determineMapBounds(mapApi: MapApi): Point2D {
-    // TODO Binary Search this.
-    // Start from the last spawn positions to save time.
-    let maxX: number = 0;
-    let maxY: number = 0;
-    mapApi.getStartingLocations().forEach((point) => {
-        if (point.x > maxX) {
-            maxX = point.x;
-        }
-        if (point.y > maxY) {
-            maxY = point.y;
-        }
-    });
-    // Expand outwards until we find the bounds.
-    for (let testX = maxX; testX < 10000; ++testX) {
-        if (mapApi.getTile(testX, 0) == undefined) {
-            maxX = testX;
-            break;
-        }
-    }
-    for (let testY = maxY; testY < 10000; ++testY) {
-        if (mapApi.getTile(testY, 0) == undefined) {
-            maxY = testY;
-            break;
-        }
-    }
-    return { x: maxX, y: maxY };
-}
-
-export function calculateAreaVisibility(
-    mapApi: MapApi,
-    playerData: PlayerData,
-    startPoint: Point2D,
-    endPoint: Point2D
-): { visibleTiles: number; validTiles: number } {
-    let validTiles: number = 0,
-        visibleTiles: number = 0;
-    for (let xx = startPoint.x; xx < endPoint.x; ++xx) {
-        for (let yy = startPoint.y; yy < endPoint.y; ++yy) {
-            let tile = mapApi.getTile(xx, yy);
-            if (tile) {
-                ++validTiles;
-                if (mapApi.isVisibleTile(tile, playerData.name)) {
-                    ++visibleTiles;
-                }
-            }
-        }
-    }
-    let result = { visibleTiles, validTiles };
-    return result;
-}
-
-export function getPointTowardsOtherPoint(
-    gameApi: GameApi,
-    startLocation: Point2D,
-    endLocation: Point2D,
-    minRadius: number,
-    maxRadius: number,
-    randomAngle: number
-): Point2D {
-    let radius = minRadius + Math.round(gameApi.generateRandom() * (maxRadius - minRadius));
-    let directionToSpawn = Math.atan2(endLocation.y - startLocation.y, endLocation.x - startLocation.x);
-    let randomisedDirection =
-        directionToSpawn - (randomAngle * (Math.PI / 12) + 2 * randomAngle * gameApi.generateRandom() * (Math.PI / 12));
-    let candidatePointX = Math.round(startLocation.x + Math.cos(randomisedDirection) * radius);
-    let candidatePointY = Math.round(startLocation.y + Math.sin(randomisedDirection) * radius);
-    return { x: candidatePointX, y: candidatePointY };
-}
-
-export function getDistanceBetweenPoints(startLocation: Point2D, endLocation: Point2D): number {
-    return Math.sqrt((startLocation.x - endLocation.x) ** 2 + (startLocation.y - endLocation.y) ** 2);
-}
-
-export function getDistanceBetweenUnits(unit1: UnitData, unit2: UnitData): number {
-    return getDistanceBetweenPoints({ x: unit1.tile.rx, y: unit1.tile.ry }, { x: unit2.tile.rx, y: unit2.tile.ry });
-}
-
-export function getDistanceBetween(unit: UnitData, point: Point2D): number {
-    return getDistanceBetweenPoints({ x: unit.tile.rx, y: unit.tile.ry }, point);
-}
+import { GameApi, MapApi, PlayerData, Point2D, Tile, UnitData } from "@chronodivide/game-api";
+import _ from "lodash";
+
+const MAX_WIDTH_AND_HEIGHT = 500;
+
+// Expensive one-time call to determine the size of the map.
+// The result is a point just outside the bounds of the map.
+export function determineMapBounds(mapApi: MapApi): Point2D {
+    // Probably want to ask for an API change to get this.
+    // Note that the maps is not always a rectangle!
+    const zeroTile = { rx: 0, ry: 0 } as Tile;
+    const allTiles = mapApi.getTilesInRect(zeroTile, { width: MAX_WIDTH_AND_HEIGHT, height: MAX_WIDTH_AND_HEIGHT });
+
+    const maxX = _.maxBy(allTiles, (tile) => tile.rx)?.rx!;
+    const maxY = _.maxBy(allTiles, (tile) => tile.ry)?.ry!;
+
+    return { x: maxX, y: maxY };
+}
+
+export function calculateAreaVisibility(
+    mapApi: MapApi,
+    playerData: PlayerData,
+    startPoint: Point2D,
+    endPoint: Point2D,
+): { visibleTiles: number; validTiles: number } {
+    let validTiles: number = 0,
+        visibleTiles: number = 0;
+    for (let xx = startPoint.x; xx < endPoint.x; ++xx) {
+        for (let yy = startPoint.y; yy < endPoint.y; ++yy) {
+            let tile = mapApi.getTile(xx, yy);
+            if (tile) {
+                ++validTiles;
+                if (mapApi.isVisibleTile(tile, playerData.name)) {
+                    ++visibleTiles;
+                }
+            }
+        }
+    }
+    let result = { visibleTiles, validTiles };
+    return result;
+}
+
+export function getPointTowardsOtherPoint(
+    gameApi: GameApi,
+    startLocation: Point2D,
+    endLocation: Point2D,
+    minRadius: number,
+    maxRadius: number,
+    randomAngle: number,
+): Point2D {
+    let radius = minRadius + Math.round(gameApi.generateRandom() * (maxRadius - minRadius));
+    let directionToSpawn = Math.atan2(endLocation.y - startLocation.y, endLocation.x - startLocation.x);
+    let randomisedDirection =
+        directionToSpawn - (randomAngle * (Math.PI / 12) + 2 * randomAngle * gameApi.generateRandom() * (Math.PI / 12));
+    let candidatePointX = Math.round(startLocation.x + Math.cos(randomisedDirection) * radius);
+    let candidatePointY = Math.round(startLocation.y + Math.sin(randomisedDirection) * radius);
+    return { x: candidatePointX, y: candidatePointY };
+}
+
+export function getDistanceBetweenPoints(startLocation: Point2D, endLocation: Point2D): number {
+    return Math.sqrt((startLocation.x - endLocation.x) ** 2 + (startLocation.y - endLocation.y) ** 2);
+}
+
+export function getDistanceBetweenUnits(unit1: UnitData, unit2: UnitData): number {
+    return getDistanceBetweenPoints({ x: unit1.tile.rx, y: unit1.tile.ry }, { x: unit2.tile.rx, y: unit2.tile.ry });
+}
+
+export function getDistanceBetween(unit: UnitData, point: Point2D): number {
+    return getDistanceBetweenPoints({ x: unit.tile.rx, y: unit.tile.ry }, point);
+}

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

@@ -6,12 +6,36 @@ 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: Point2D,
         public sectorStartTile: Tile | undefined,
         public sectorVisibilityPct: number | undefined,
-        public sectorVisibilityLastCheckTick: 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 {
@@ -34,7 +58,7 @@ export class SectorCache {
                     { x: xx * SECTOR_SIZE, y: yy * SECTOR_SIZE },
                     mapApi.getTile(xx * SECTOR_SIZE, yy * SECTOR_SIZE),
                     undefined,
-                    undefined
+                    undefined,
                 );
             }
         }
@@ -127,10 +151,28 @@ export class SectorCache {
         return this.sectors[sectorX][sectorY];
     }
 
-    public getSectorForWorldPosition(x: number, y: number): Sector | undefined {
+    public getSectorBounds(): Point2D {
+        return {
+            x: this.sectorsX,
+            y: this.sectorsY,
+        }
+    }
+
+    public getSectorCoordinatesForWorldPosition(x: number, y: number) {
         if (x < 0 || x >= this.mapBounds.x || y < 0 || y >= this.mapBounds.y) {
             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/mission.ts

@@ -1,7 +1,7 @@
 import { GameApi, PlayerData } from "@chronodivide/game-api";
 import { Squad } from "../squad/squad.js";
-import { GlobalThreat } from "../threat/threat.js";
 import { MatchAwareness } from "../awareness.js";
+import { DebugLogger } from "../common/utils.js";
 
 // AI starts Missions based on heuristics, which have one or more squads.
 // Missions can create squads (but squads will disband themselves).
@@ -11,7 +11,7 @@ export abstract class Mission<FailureReasons = undefined> {
 
     private onFinish: (reason: FailureReasons, squad: Squad | null) => void = () => {};
 
-    constructor(private uniqueName: string, private priority: number = 1) {}
+    constructor(private uniqueName: string, private priority: number, protected logger: DebugLogger) {}
 
     abstract onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction;
 

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

@@ -1,7 +1,6 @@
 // Meta-controller for forming and controlling squads.
 
 import { GameApi, PlayerData } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
 import { Mission, MissionAction, MissionActionDisband, MissionActionRegisterSquad } from "./mission.js";
 import { SquadController } from "../squad/squadController.js";
 import { MatchAwareness } from "../awareness.js";
@@ -70,9 +69,9 @@ export class MissionController {
 
         // Create dynamic missions.
         this.missionFactories.forEach((missionFactory) => {
-            missionFactory.maybeCreateMissions(gameApi, playerData, matchAwareness, this);
+            missionFactory.maybeCreateMissions(gameApi, playerData, matchAwareness, this, this.logger);
             disbandedMissionsArray.forEach(({ reason, mission }) => {
-                missionFactory.onMissionFailed(gameApi, playerData, matchAwareness, mission, reason, this);
+                missionFactory.onMissionFailed(gameApi, playerData, matchAwareness, mission, reason, this, this.logger);
             });
         });
     }

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

@@ -6,6 +6,7 @@ import { ScoutingMissionFactory } from "./missions/scoutingMission.js";
 import { AttackMissionFactory } from "./missions/attackMission.js";
 import { MissionController } from "./missionController.js";
 import { DefenceMissionFactory } from "./missions/defenceMission.js";
+import { DebugLogger } from "../common/utils.js";
 
 export interface MissionFactory {
     getName(): string;
@@ -23,6 +24,7 @@ export interface MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
+        logger: DebugLogger
     ): void;
 
     /**
@@ -35,6 +37,7 @@ export interface MissionFactory {
         failedMission: Mission,
         failureReason: any,
         missionController: MissionController,
+        logger: DebugLogger
     ): void;
 }
 

package/src/bot/logic/mission/missions/attackMission.ts

@@ -11,6 +11,7 @@ import { MissionController } from "../missionController.js";
 import { match } from "assert";
 import { RetreatMission } from "./retreatMission.js";
 import _ from "lodash";
+import { DebugLogger } from "../../common/utils.js";
 
 export enum AttackFailReason {
     NoTargets = 0,
@@ -31,8 +32,9 @@ export class AttackMission extends Mission<AttackFailReason> {
         private rallyArea: Point2D,
         private attackArea: Point2D,
         private radius: number,
+        logger: DebugLogger
     ) {
-        super(uniqueName, priority);
+        super(uniqueName, priority, logger);
     }
 
     onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
@@ -104,6 +106,7 @@ export class AttackMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
+        logger: DebugLogger
     ): void {
         if (!matchAwareness.shouldAttack()) {
             return;
@@ -125,7 +128,7 @@ export class AttackMissionFactory implements MissionFactory {
         const squadName = "globalAttack";
 
         const tryAttack = missionController.addMission(
-            new AttackMission(squadName, 100, matchAwareness.getMainRallyPoint(), attackArea, attackRadius).then(
+            new AttackMission(squadName, 100, matchAwareness.getMainRallyPoint(), attackArea, attackRadius, logger).then(
                 (reason, squad) => {
                     missionController.addMission(
                         new RetreatMission(
@@ -133,6 +136,7 @@ export class AttackMissionFactory implements MissionFactory {
                             100,
                             matchAwareness.getMainRallyPoint(),
                             squad?.getUnitIds() ?? [],
+                            logger,
                         ),
                     );
                 },