@supalosa/chronodivide-bot 0.2.1 → 0.2.2-a

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@supalosa/chronodivide-bot",
-    "version": "0.2.1",
+    "version": "0.2.2a",
     "description": "Example bot for Chrono Divide",
     "repository": "https://github.com/Supalosa/supalosa-chronodivide-bot",
     "main": "dist/exampleBot.js",
@@ -13,17 +13,25 @@
     },
     "license": "UNLICENSED",
     "devDependencies": {
-        "@timohausmann/quadtree-ts": "^2.0.0-beta.1",
+        "@chronodivide/game-api": "^0.45.0",
+        "@types/lodash.countby": "^4.6.8",
+        "@types/lodash.maxby": "^4.6.8",
+        "@types/lodash.min": "^4.0.8",
+        "@types/lodash.uniqby": "^4.7.8",
         "@types/node": "^14.17.32",
         "prettier": "3.0.3",
         "typescript": "^4.3.5"
     },
+    "peerDependencies": {
+        "@chronodivide/game-api": "^0.45.0"
+    },
     "dependencies": {
-        "@chronodivide/game-api": "^0.45.0",
-        "@types/lodash": "^4.14.199",
+        "@datastructures-js/priority-queue": "^6.3.0",
+        "@timohausmann/quadtree-ts": "^2.0.0-beta.1",
         "@types/luxon": "^3.3.2",
-        "lodash": "^4.17.21",
-        "luxon": "^3.4.3",
-        "priority-queue-typescript": "^1.0.1"
+        "lodash.countby": "^4.6.0",
+        "lodash.maxby": "^4.6.0",
+        "lodash.min": "^4.0.1",
+        "lodash.uniqby": "^4.7.0"
     }
 }

package/src/bot/bot.ts

@@ -10,21 +10,22 @@ import {
     FactoryType,
 } from "@chronodivide/game-api";
 
-import { Duration } from "luxon";
-
 import { determineMapBounds } from "./logic/map/map.js";
 import { SectorCache } from "./logic/map/sector.js";
 import { MissionController } from "./logic/mission/missionController.js";
 import { SquadController } from "./logic/squad/squadController.js";
 import { QUEUES, QueueController, queueTypeToName } from "./logic/building/queueController.js";
-import { MatchAwareness as MatchAwareness, MatchAwarenessImpl } from "./logic/awareness.js";
+import { MatchAwareness, MatchAwarenessImpl } from "./logic/awareness.js";
+import { formatTimeDuration } from "./logic/common/utils.js";
 
 const DEBUG_TIMESTAMP_OUTPUT_INTERVAL_SECONDS = 60;
+
+// Number of ticks per second at the base speed.
 const NATURAL_TICK_RATE = 15;
 const BOT_AUTO_SURRENDER_TIME_SECONDS = 7200; // 7200; // 2 hours (approx 30 mins in real game)
 
 export class SupalosaBot extends Bot {
-    private tickRatio!: number;
+    private tickRatio?: number;
     private knownMapBounds: Point2D | undefined;
     private missionController: MissionController;
     private squadController: SquadController;
@@ -50,13 +51,15 @@ export class SupalosaBot extends Bot {
         this.tickRatio = Math.ceil(gameRate / botRate);
 
         this.knownMapBounds = determineMapBounds(game.mapApi);
+        const myPlayer = game.getPlayerData(this.name);
 
         this.matchAwareness = new MatchAwarenessImpl(
             null,
             new SectorCache(game.mapApi, this.knownMapBounds),
-            game.getPlayerData(this.name).startLocation,
+            myPlayer.startLocation,
             (message, sayInGame) => this.logBotStatus(message, sayInGame),
         );
+        this.matchAwareness.onGameStart(game, myPlayer);
 
         this.logBotStatus(`Map bounds: ${this.knownMapBounds.x}, ${this.knownMapBounds.y}`);
     }
@@ -72,7 +75,7 @@ export class SupalosaBot extends Bot {
             this.logDebugState(game);
         }
 
-        if (game.getCurrentTick() % this.tickRatio === 0) {
+        if (game.getCurrentTick() % this.tickRatio! === 0) {
             const myPlayer = game.getPlayerData(this.name);
 
             this.matchAwareness.onAiUpdate(game, myPlayer);
@@ -122,7 +125,7 @@ export class SupalosaBot extends Bot {
     }
 
     private getHumanTimestamp(game: GameApi) {
-        return Duration.fromMillis((game.getCurrentTick() / NATURAL_TICK_RATE) * 1000).toFormat("hh:mm:ss");
+        return formatTimeDuration(game.getCurrentTick() / NATURAL_TICK_RATE);
     }
 
     private logBotStatus(message: string, sayInGame: boolean = false) {

package/src/bot/logic/awareness.ts

@@ -1,9 +1,12 @@
 import { GameApi, ObjectType, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
 import { SectorCache } from "./map/sector";
 import { GlobalThreat } from "./threat/threat";
-import { calculateGlobalThreat } from "../logic/threat/threatCalculator.js";
-import { determineMapBounds, getDistanceBetweenPoints, getPointTowardsOtherPoint } from "../logic/map/map.js";
-import { Circle, Quadtree, Rectangle } from "@timohausmann/quadtree-ts";
+import { calculateGlobalThreat } from "./threat/threatCalculator.js";
+import { determineMapBounds, getDistanceBetweenPoints, getPointTowardsOtherPoint } from "./map/map.js";
+import { Circle, Quadtree } from "@timohausmann/quadtree-ts";
+import { ScoutingManager } from "./common/scout.js";
+
+export type UnitPositionQuery = { x: number; y: number; unitId: number };
 
 /**
  * The bot's understanding of the current state of the game.
@@ -31,6 +34,8 @@ export interface MatchAwareness {
      */
     getMainRallyPoint(): Point2D;
 
+    onGameStart(gameApi: GameApi, playerData: PlayerData): void;
+
     /**
      * Update the internal state of the Ai.
      * @param gameApi
@@ -42,6 +47,8 @@ export interface MatchAwareness {
      * True if the AI should initiate an attack.
      */
     shouldAttack(): boolean;
+
+    getScoutingManager(): ScoutingManager;
 }
 
 const SECTORS_TO_UPDATE_PER_CYCLE = 8;
@@ -51,7 +58,6 @@ const RALLY_POINT_UPDATE_INTERVAL_TICKS = 60;
 const THREAT_UPDATE_INTERVAL_TICKS = 30;
 
 type QTUnit = Circle<number>;
-export type UnitPositionQuery = { x: number; y: number; unitId: number };
 
 const rebuildQuadtree = (quadtree: Quadtree<QTUnit>, units: UnitData[]) => {
     quadtree.clear();
@@ -64,6 +70,7 @@ export class MatchAwarenessImpl implements MatchAwareness {
     private _shouldAttack: boolean = false;
 
     private hostileQuadTree: Quadtree<QTUnit>;
+    private scoutingManager: ScoutingManager;
 
     constructor(
         private threatCache: GlobalThreat | null,
@@ -73,6 +80,7 @@ export class MatchAwarenessImpl implements MatchAwareness {
     ) {
         const { x: width, y: height } = sectorCache.getMapBounds();
         this.hostileQuadTree = new Quadtree({ width, height });
+        this.scoutingManager = new ScoutingManager(logger);
     }
 
     getHostilesNearPoint2d(point: Point2D, radius: number): UnitPositionQuery[] {
@@ -96,6 +104,9 @@ export class MatchAwarenessImpl implements MatchAwareness {
     getMainRallyPoint(): Point2D {
         return this.mainRallyPoint;
     }
+    getScoutingManager(): ScoutingManager {
+        return this.scoutingManager;
+    }
 
     shouldAttack(): boolean {
         return this._shouldAttack;
@@ -121,11 +132,17 @@ export class MatchAwarenessImpl implements MatchAwareness {
         return hostilePlayerNames.includes(unit.owner);
     }
 
+    public onGameStart(gameApi: GameApi, playerData: PlayerData) {
+        this.scoutingManager.onGameStart(gameApi, playerData, this.sectorCache);
+    }
+
     onAiUpdate(game: GameApi, playerData: PlayerData): void {
         const sectorCache = this.sectorCache;
 
         sectorCache.updateSectors(game.getCurrentTick(), SECTORS_TO_UPDATE_PER_CYCLE, game.mapApi, playerData);
 
+        this.scoutingManager.onAiUpdate(game, playerData);
+
         let updateRatio = sectorCache?.getSectorUpdateRatio(game.getCurrentTick() - game.getTickRate() * 60);
         if (updateRatio && updateRatio < 1.0) {
             this.logger(`${updateRatio * 100.0}% of sectors updated in last 60 seconds.`);

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

@@ -1,60 +1,60 @@
-import { GameApi, PlayerData, Point2D, TechnoRules } from "@chronodivide/game-api";
-import { getPointTowardsOtherPoint } from "../map/map.js";
-import { GlobalThreat } from "../threat/threat.js";
-import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
-
-export class AntiGroundStaticDefence implements AiBuildingRules {
-    constructor(private basePriority: number, private baseAmount: number, private strength: number) {}
-
-    getPlacementLocation(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules
-    ): { rx: number; ry: number } | undefined {
-        // Prefer front towards enemy.
-        let startLocation = playerData.startLocation;
-        let players = game.getPlayers();
-        let enemyFacingLocationCandidates: Point2D[] = [];
-        for (let i = 0; i < players.length; ++i) {
-            let playerName = players[i];
-            if (playerName == playerData.name) {
-                continue;
-            }
-            let enemyPlayer = game.getPlayerData(playerName);
-            enemyFacingLocationCandidates.push(
-                getPointTowardsOtherPoint(game, startLocation, enemyPlayer.startLocation, 4, 16, 1.5)
-            );
-        }
-        let selectedLocation =
-            enemyFacingLocationCandidates[Math.floor(game.generateRandom() * enemyFacingLocationCandidates.length)];
-        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules);
-    }
-
-    getPriority(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number {
-        // If the enemy's ground power is increasing we should try to keep up.
-        if (threatCache) {
-            let denominator =
-                threatCache.totalAvailableAntiGroundFirepower + threatCache.totalDefensivePower + this.strength;
-            if (threatCache.totalOffensiveLandThreat > denominator * 1.1) {
-                return this.basePriority * (threatCache.totalOffensiveLandThreat / Math.max(1, denominator));
-            }
-        }
-        const strengthPerCost = (this.strength / technoRules.cost) * 1000;
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        return this.basePriority * (1.0 - numOwned / this.baseAmount) * strengthPerCost;
-    }
-
-    getMaxCount(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number | null {
-        return null;
-    }
-}
+import { GameApi, PlayerData, Point2D, TechnoRules } from "@chronodivide/game-api";
+import { getPointTowardsOtherPoint } from "../map/map.js";
+import { GlobalThreat } from "../threat/threat.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
+
+export class AntiGroundStaticDefence implements AiBuildingRules {
+    constructor(private basePriority: number, private baseAmount: number, private strength: number) {}
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules
+    ): { rx: number; ry: number } | undefined {
+        // Prefer front towards enemy.
+        let startLocation = playerData.startLocation;
+        let players = game.getPlayers();
+        let enemyFacingLocationCandidates: Point2D[] = [];
+        for (let i = 0; i < players.length; ++i) {
+            let playerName = players[i];
+            if (playerName == playerData.name) {
+                continue;
+            }
+            let enemyPlayer = game.getPlayerData(playerName);
+            enemyFacingLocationCandidates.push(
+                getPointTowardsOtherPoint(game, startLocation, enemyPlayer.startLocation, 4, 16, 1.5)
+            );
+        }
+        let selectedLocation =
+            enemyFacingLocationCandidates[Math.floor(game.generateRandom() * enemyFacingLocationCandidates.length)];
+        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules, 0);
+    }
+
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number {
+        // If the enemy's ground power is increasing we should try to keep up.
+        if (threatCache) {
+            let denominator =
+                threatCache.totalAvailableAntiGroundFirepower + threatCache.totalDefensivePower + this.strength;
+            if (threatCache.totalOffensiveLandThreat > denominator * 1.1) {
+                return this.basePriority * (threatCache.totalOffensiveLandThreat / Math.max(1, denominator));
+            }
+        }
+        const strengthPerCost = (this.strength / technoRules.cost) * 1000;
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        return this.basePriority * (1.0 - numOwned / this.baseAmount) * strengthPerCost;
+    }
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number | null {
+        return null;
+    }
+}

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

@@ -0,0 +1,68 @@
+import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
+
+export class ArtilleryUnit implements AiBuildingRules {
+    constructor(private basePriority: number,
+        private artilleryPower: number,
+        private antiGroundPower: number,
+        private baseAmount: number) {}
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules
+    ): { rx: number; ry: number } | undefined {
+        return undefined;
+    }
+
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number {
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        let priority = this.basePriority;
+        // If the enemy's defensive power is increasing we will start to build these.
+        if (threatCache && threatCache.totalDefensivePower > threatCache.totalAvailableAntiGroundFirepower) {
+            priority += (
+                this.artilleryPower *
+                (threatCache.totalAvailableAntiGroundFirepower / Math.max(1, threatCache.totalDefensivePower))
+            );
+        }
+        if (threatCache && this.antiGroundPower > 0) {
+            // If the enemy's power is increasing we should try to keep up.
+            if (threatCache.totalOffensiveLandThreat > threatCache.totalAvailableAntiGroundFirepower) {
+                priority +=
+                    this.antiGroundPower *
+                    this.basePriority *
+                    (threatCache.totalOffensiveLandThreat /
+                        Math.max(1, threatCache.totalAvailableAntiGroundFirepower));
+            } else {
+                // But also, if our power dwarfs the enemy, keep pressing the advantage.
+                priority +=
+                    (this.antiGroundPower *
+                        this.basePriority *
+                        Math.sqrt(
+                            threatCache.totalAvailableAntiGroundFirepower /
+                                Math.max(
+                                    1,
+                                    threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat,
+                                ),
+                        )) /
+                    (numOwned + 1);
+            }
+        }
+        return priority * (1.0 - numOwned / this.baseAmount);
+    }
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number | null {
+        return null;
+    }
+}

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

@@ -1,68 +1,68 @@
-import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
-import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
-
-export class BasicAirUnit implements AiBuildingRules {
-    constructor(
-        private basePriority: number,
-        private baseAmount: number,
-        private antiGroundPower: number = 1, // boolean for now, but will eventually be used in weighting.
-        private antiAirPower: number = 0
-    ) {}
-
-    getPlacementLocation(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules
-    ): { rx: number; ry: number } | undefined {
-        return undefined;
-    }
-
-    getPriority(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number {
-        // If the enemy's anti-air power is low we might build more.
-        if (threatCache) {
-            let priority = 0;
-            if (
-                this.antiGroundPower > 0 &&
-                threatCache.totalOffensiveLandThreat > threatCache.totalAvailableAntiGroundFirepower
-            ) {
-                priority +=
-                    this.basePriority *
-                    (threatCache.totalOffensiveLandThreat / Math.max(1, threatCache.totalAvailableAntiGroundFirepower));
-            }
-            if (
-                this.antiAirPower > 0 &&
-                threatCache.totalOffensiveAirThreat > threatCache.totalAvailableAntiAirFirepower
-            ) {
-                priority +=
-                    this.basePriority *
-                    (threatCache.totalOffensiveAirThreat / Math.max(1, threatCache.totalAvailableAntiAirFirepower));
-            }
-            // sqrt so we don't build too much of one unit type.
-            priority += Math.min(
-                1.0,
-                Math.max(
-                    1,
-                    Math.sqrt(threatCache.totalAvailableAirPower / Math.max(1, threatCache.totalOffensiveAntiAirThreat))
-                )
-            );
-            return this.baseAmount * priority;
-        }
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        return this.basePriority * (1.0 - numOwned / this.baseAmount);
-    }
-
-    getMaxCount(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number | null {
-        return null;
-    }
-}
+import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
+
+export class BasicAirUnit implements AiBuildingRules {
+    constructor(
+        private basePriority: number,
+        private baseAmount: number,
+        private antiGroundPower: number = 1, // boolean for now, but will eventually be used in weighting.
+        private antiAirPower: number = 0
+    ) {}
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules
+    ): { rx: number; ry: number } | undefined {
+        return undefined;
+    }
+
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number {
+        // If the enemy's anti-air power is low we might build more.
+        if (threatCache) {
+            let priority = 0;
+            if (
+                this.antiGroundPower > 0 &&
+                threatCache.totalOffensiveLandThreat > threatCache.totalAvailableAntiGroundFirepower
+            ) {
+                priority +=
+                    this.basePriority *
+                    (threatCache.totalOffensiveLandThreat / Math.max(1, threatCache.totalAvailableAntiGroundFirepower));
+            }
+            if (
+                this.antiAirPower > 0 &&
+                threatCache.totalOffensiveAirThreat > threatCache.totalAvailableAntiAirFirepower
+            ) {
+                priority +=
+                    this.basePriority *
+                    (threatCache.totalOffensiveAirThreat / Math.max(1, threatCache.totalAvailableAntiAirFirepower));
+            }
+            // sqrt so we don't build too much of one unit type.
+            priority += Math.min(
+                1.0,
+                Math.max(
+                    1,
+                    Math.sqrt(threatCache.totalAvailableAirPower / Math.max(1, threatCache.totalOffensiveAntiAirThreat))
+                )
+            );
+            return this.baseAmount * priority;
+        }
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        return this.basePriority * (1.0 - numOwned / this.baseAmount);
+    }
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number | null {
+        return null;
+    }
+}

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

@@ -1,47 +1,47 @@
-import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
-import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
-import { GlobalThreat } from "../threat/threat.js";
-
-export class BasicBuilding implements AiBuildingRules {
-    constructor(
-        protected basePriority: number,
-        protected maxNeeded: number,
-        protected onlyBuildWhenFloatingCreditsAmount?: number
-    ) {}
-
-    getPlacementLocation(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules
-    ): { rx: number; ry: number } | undefined {
-        return getDefaultPlacementLocation(game, playerData, playerData.startLocation, technoRules);
-    }
-
-    getPriority(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number {
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        const calcMaxCount = this.getMaxCount(game, playerData, technoRules, threatCache);
-        if (numOwned >= (calcMaxCount ?? this.maxNeeded)) {
-            return -100;
-        }
-
-        if (this.onlyBuildWhenFloatingCreditsAmount && playerData.credits < this.onlyBuildWhenFloatingCreditsAmount) {
-            return -100;
-        }
-
-        return this.basePriority * (1.0 - numOwned / this.maxNeeded);
-    }
-
-    getMaxCount(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number | null {
-        return this.maxNeeded;
-    }
-}
+import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
+import { GlobalThreat } from "../threat/threat.js";
+
+export class BasicBuilding implements AiBuildingRules {
+    constructor(
+        protected basePriority: number,
+        protected maxNeeded: number,
+        protected onlyBuildWhenFloatingCreditsAmount?: number
+    ) {}
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules
+    ): { rx: number; ry: number } | undefined {
+        return getDefaultPlacementLocation(game, playerData, playerData.startLocation, technoRules);
+    }
+
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number {
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        const calcMaxCount = this.getMaxCount(game, playerData, technoRules, threatCache);
+        if (numOwned >= (calcMaxCount ?? this.maxNeeded)) {
+            return -100;
+        }
+
+        if (this.onlyBuildWhenFloatingCreditsAmount && playerData.credits < this.onlyBuildWhenFloatingCreditsAmount) {
+            return -100;
+        }
+
+        return this.basePriority * (1.0 - numOwned / this.maxNeeded);
+    }
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number | null {
+        return this.maxNeeded;
+    }
+}

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

@@ -1,6 +1,6 @@
 import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
 import { GlobalThreat } from "../threat/threat.js";
-import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
 
 export class BasicGroundUnit implements AiBuildingRules {
     constructor(