@supalosa/chronodivide-bot 0.2.0 → 0.2.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";
@@ -13,7 +12,7 @@ export class MissionController {
 
     private forceDisbandedMissions: string[] = [];
 
-    constructor(private logger: (message: string) => void) {
+    constructor(private logger: (message: string, sayInGame?: boolean) => void) {
         this.missionFactories = createMissionFactories();
     }
 
@@ -48,11 +47,13 @@ export class MissionController {
         this.missions
             .filter((missions) => disbandedMissions.has(missions.getUniqueName()))
             .forEach((disbandedMission) => {
-                this.logger(`mission disbanded: ${disbandedMission.getUniqueName()}`);
                 const reason = disbandedMissions.get(disbandedMission.getUniqueName());
+                this.logger(
+                    `mission disbanded: ${disbandedMission.getUniqueName()}, reason: ${reason}, hasSquad: ${!!disbandedMission.getSquad}`,
+                );
                 disbandedMissionsArray.push({ mission: disbandedMission, reason });
-                disbandedMission.getSquad()?.setMission(null);
                 disbandedMission.endMission(disbandedMissions.get(disbandedMission.getUniqueName()));
+                disbandedMission.getSquad()?.setMission(null);
             });
         this.missions = this.missions.filter((missions) => !disbandedMissions.has(missions.getUniqueName()));
 
@@ -68,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;
@@ -124,18 +127,21 @@ export class AttackMissionFactory implements MissionFactory {
         // TODO: not using a fixed value here. But performance slows to a crawl when this is unique.
         const squadName = "globalAttack";
 
-        const tryAttack = missionController
-            .addMission(new AttackMission(squadName, 100, matchAwareness.getMainRallyPoint(), attackArea, attackRadius))
-            ?.then((reason, squad) => {
-                missionController.addMission(
-                    new RetreatMission(
-                        "retreat-from-" + squadName + gameApi.getCurrentTick(),
-                        100,
-                        matchAwareness.getMainRallyPoint(),
-                        squad?.getUnitIds() ?? [],
-                    ),
-                );
-            });
+        const tryAttack = missionController.addMission(
+            new AttackMission(squadName, 100, matchAwareness.getMainRallyPoint(), attackArea, attackRadius, logger).then(
+                (reason, squad) => {
+                    missionController.addMission(
+                        new RetreatMission(
+                            "retreat-from-" + squadName + gameApi.getCurrentTick(),
+                            100,
+                            matchAwareness.getMainRallyPoint(),
+                            squad?.getUnitIds() ?? [],
+                            logger,
+                        ),
+                    );
+                },
+            ),
+        );
         if (tryAttack) {
             this.lastAttackAt = gameApi.getCurrentTick();
         }

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

@@ -6,6 +6,7 @@ import { MissionFactory } from "../missionFactories.js";
 import { Squad } from "../../squad/squad.js";
 import { CombatSquad } from "../../squad/behaviours/combatSquad.js";
 import { RetreatMission } from "./retreatMission.js";
+import { DebugLogger } from "../../common/utils.js";
 
 export enum DefenceFailReason {
     NoTargets,
@@ -22,8 +23,9 @@ export class DefenceMission extends Mission<DefenceFailReason> {
         priority: number,
         private defenceArea: Point2D,
         private radius: number,
+        logger: DebugLogger,
     ) {
-        super(uniqueName, priority);
+        super(uniqueName, priority, logger);
     }
 
     onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
@@ -35,8 +37,15 @@ export class DefenceMission extends Mission<DefenceFailReason> {
             const foundTargets = matchAwareness.getHostilesNearPoint2d(this.defenceArea, this.radius);
 
             if (foundTargets.length === 0) {
+                this.logger(`(Defence Mission ${this.getUniqueName()}): No targets found, disbanding.`);
                 return disbandMission(DefenceFailReason.NoTargets);
             } else {
+                const targetUnit = gameApi.getUnitData(foundTargets[0].unitId);
+                this.logger(
+                    `(Defence Mission ${this.getUniqueName()}): Focused on target ${targetUnit?.name} (${
+                        foundTargets.length
+                    } found in area ${this.radius})`,
+                );
                 this.combatSquad?.setAttackArea({ x: foundTargets[0].x, y: foundTargets[0].y });
             }
         }
@@ -47,9 +56,9 @@ export class DefenceMission extends Mission<DefenceFailReason> {
 const DEFENCE_CHECK_TICKS = 30;
 
 // Starting radius around the player's base to trigger defense.
-const DEFENCE_STARTING_RADIUS = 20;
+const DEFENCE_STARTING_RADIUS = 10;
 // Every game tick, we increase the defendable area by this amount.
-const DEFENCE_RADIUS_INCREASE_PER_GAME_TICK = 0.005;
+const DEFENCE_RADIUS_INCREASE_PER_GAME_TICK = 0.001;
 
 export class DefenceMissionFactory implements MissionFactory {
     private lastDefenceCheckAt = 0;
@@ -65,6 +74,7 @@ export class DefenceMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
+        logger: DebugLogger,
     ): void {
         if (gameApi.getCurrentTick() < this.lastDefenceCheckAt + DEFENCE_CHECK_TICKS) {
             return;
@@ -76,19 +86,29 @@ export class DefenceMissionFactory implements MissionFactory {
         const enemiesNearSpawn = matchAwareness.getHostilesNearPoint2d(playerData.startLocation, defendableRadius);
 
         if (enemiesNearSpawn.length > 0) {
+            logger(
+                `Starting defence mission, ${
+                    enemiesNearSpawn.length
+                } found in radius ${defendableRadius} (tick ${gameApi.getCurrentTick()})`,
+            );
             missionController.addMission(
-                new DefenceMission("globalDefence", 1000, playerData.startLocation, defendableRadius * 1.2)?.then(
-                    (reason, squad) => {
-                        missionController.addMission(
-                            new RetreatMission(
-                                "retreat-from-globalDefence" + gameApi.getCurrentTick(),
-                                100,
-                                matchAwareness.getMainRallyPoint(),
-                                squad?.getUnitIds() ?? [],
-                            ),
-                        );
-                    },
-                ),
+                new DefenceMission(
+                    "globalDefence",
+                    1000,
+                    playerData.startLocation,
+                    defendableRadius * 1.2,
+                    logger,
+                ).then((reason, squad) => {
+                    missionController.addMission(
+                        new RetreatMission(
+                            "retreat-from-globalDefence" + gameApi.getCurrentTick(),
+                            100,
+                            matchAwareness.getMainRallyPoint(),
+                            squad?.getUnitIds() ?? [],
+                            logger,
+                        ),
+                    );
+                }),
             );
         }
     }

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

@@ -5,15 +5,16 @@ import { ExpansionSquad } from "../../squad/behaviours/expansionSquad.js";
 import { MissionFactory } from "../missionFactories.js";
 import { OneTimeMission } from "./oneTimeMission.js";
 import { MatchAwareness } from "../../awareness.js";
-import { AttackFailReason, AttackMission } from "./attackMission.js";
 import { MissionController } from "../missionController.js";
+import { DebugLogger } from "../../common/utils.js";
 
 /**
  * A mission that tries to create an MCV (if it doesn't exist) and deploy it somewhere it can be deployed.
  */
 export class ExpansionMission extends OneTimeMission {
-    constructor(uniqueName: string, priority: number, selectedMcv: number | null) {
-        super(uniqueName, priority, () => new ExpansionSquad(selectedMcv));
+    constructor(uniqueName: string, priority: number, selectedMcv: number | null, 
+        logger: DebugLogger) {
+        super(uniqueName, priority, () => new ExpansionSquad(selectedMcv), logger);
     }
 }
 
@@ -27,13 +28,14 @@ export class ExpansionMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
+        logger: DebugLogger
     ): void {
         // At this point, only expand if we have a loose MCV.
         const mcvs = gameApi.getVisibleUnits(playerData.name, "self", (r) =>
             gameApi.getGeneralRules().baseUnit.includes(r.name)
         );
         mcvs.forEach((mcv) => {
-            missionController.addMission(new ExpansionMission("expand-with-" + mcv, 100, mcv));
+            missionController.addMission(new ExpansionMission("expand-with-" + mcv, 100, mcv, logger));
         });
     }