@supalosa/chronodivide-bot 0.2.1 → 0.2.2-a

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 maxBy from "lodash.maxby";
+
+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,8 @@ 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";
+import { EngineerMissionFactory } from "./missions/engineerMission.js";
 
 export interface MissionFactory {
     getName(): string;
@@ -23,6 +25,7 @@ export interface MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
+        logger: DebugLogger
     ): void;
 
     /**
@@ -35,6 +38,7 @@ export interface MissionFactory {
         failedMission: Mission,
         failureReason: any,
         missionController: MissionController,
+        logger: DebugLogger
     ): void;
 }
 
@@ -43,4 +47,5 @@ export const createMissionFactories = () => [
     new ScoutingMissionFactory(),
     new AttackMissionFactory(),
     new DefenceMissionFactory(),
+    new EngineerMissionFactory(),
 ];

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

@@ -1,16 +1,13 @@
-import { AttackState, GameApi, ObjectType, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
-import { OneTimeMission } from "./oneTimeMission.js";
+import { GameApi, ObjectType, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
 import { CombatSquad } from "../../squad/behaviours/combatSquad.js";
 import { Mission, MissionAction, disbandMission, noop } from "../mission.js";
-import { GlobalThreat } from "../../threat/threat.js";
 import { Squad } from "../../squad/squad.js";
-import { getDistanceBetweenPoints, getDistanceBetweenUnits } from "../../map/map.js";
 import { MissionFactory } from "../missionFactories.js";
 import { MatchAwareness } from "../../awareness.js";
 import { MissionController } from "../missionController.js";
-import { match } from "assert";
 import { RetreatMission } from "./retreatMission.js";
-import _ from "lodash";
+import maxBy from "lodash.maxby";
+import { DebugLogger } from "../../common/utils.js";
 
 export enum AttackFailReason {
     NoTargets = 0,
@@ -31,8 +28,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 {
@@ -88,7 +86,7 @@ export class AttackMissionFactory implements MissionFactory {
                 .map((unitId) => gameApi.getUnitData(unitId))
                 .filter((u) => !!u && gameApi.getPlayerData(u.owner).isCombatant) as UnitData[];
 
-            const maxUnit = _.maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
+            const maxUnit = maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
             if (maxUnit) {
                 return { x: maxUnit.tile.rx, y: maxUnit.tile.ry };
             }
@@ -104,6 +102,7 @@ export class AttackMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
+        logger: DebugLogger,
     ): void {
         if (!matchAwareness.shouldAttack()) {
             return;
@@ -125,18 +124,24 @@ export class AttackMissionFactory implements MissionFactory {
         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() ?? [],
-                        ),
-                    );
-                },
-            ),
+            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 });
             }
         }
@@ -49,7 +58,7 @@ const DEFENCE_CHECK_TICKS = 30;
 // Starting radius around the player's base to trigger defense.
 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/engineerMission.ts

@@ -0,0 +1,61 @@
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { GlobalThreat } from "../../threat/threat.js";
+import { Mission } from "../mission.js";
+import { ExpansionSquad } from "../../squad/behaviours/expansionSquad.js";
+import { MissionFactory } from "../missionFactories.js";
+import { OneTimeMission } from "./oneTimeMission.js";
+import { MatchAwareness } from "../../awareness.js";
+import { MissionController } from "../missionController.js";
+import { DebugLogger } from "../../common/utils.js";
+import { EngineerSquad } from "../../squad/behaviours/engineerSquad.js";
+
+/**
+ * A mission that tries to send an engineer into a building (e.g. to capture tech building or repair bridge)
+ */
+export class EngineerMission extends OneTimeMission {
+    constructor(uniqueName: string, priority: number, selectedTechBuilding: number, 
+        logger: DebugLogger) {
+        super(uniqueName, priority, () => new EngineerSquad(selectedTechBuilding), logger);
+    }
+}
+
+// Only try to capture tech buildings within this radius of the starting point.
+const MAX_TECH_CAPTURE_RADIUS = 50;
+
+const TECH_CHECK_INTERVAL_TICKS = 300;
+
+export class EngineerMissionFactory implements MissionFactory {
+    private lastCheckAt = 0;
+
+    getName(): string {
+        return "EngineerMissionFactory";
+    }
+
+    maybeCreateMissions(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        missionController: MissionController,
+        logger: DebugLogger
+    ): void {
+        if (!(gameApi.getCurrentTick() > this.lastCheckAt + TECH_CHECK_INTERVAL_TICKS)) {
+            return;
+        }
+        this.lastCheckAt = gameApi.getCurrentTick();
+        const eligibleTechBuildings = gameApi.getVisibleUnits(playerData.name, "hostile", (r) => r.capturable && r.produceCashAmount > 0);
+
+        eligibleTechBuildings.forEach((techBuildingId) => {
+            missionController.addMission(new EngineerMission("capture-" + techBuildingId, 100, techBuildingId, logger));
+        });
+    }
+
+    onMissionFailed(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        failedMission: Mission,
+        failureReason: undefined,
+        missionController: MissionController,
+    ): void {
+    }
+}

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));
         });
     }
 

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

@@ -6,6 +6,7 @@ import { Squad } from "../../squad/squad.js";
 import { MissionFactory } from "../missionFactories.js";
 import { SquadBehaviour } from "../../squad/squadBehaviour.js";
 import { MatchAwareness } from "../../awareness.js";
+import { DebugLogger } from "../../common/utils.js";
 
 /**
  * A mission that gets dispatched once, and once the squad decides to disband, the mission is disbanded.
@@ -13,8 +14,8 @@ import { MatchAwareness } from "../../awareness.js";
 export abstract class OneTimeMission<T = undefined> extends Mission<T> {
     private hadSquad = false;
 
-    constructor(uniqueName: string, priority: number, private behaviourFactory: () => SquadBehaviour) {
-        super(uniqueName, priority);
+    constructor(uniqueName: string, priority: number, private behaviourFactory: () => SquadBehaviour, logger: DebugLogger) {
+        super(uniqueName, priority, logger);
     }
 
     onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {

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

@@ -1,9 +1,10 @@
 import { Point2D } from "@chronodivide/game-api";
 import { OneTimeMission } from "./oneTimeMission.js";
 import { RetreatSquad } from "../../squad/behaviours/retreatSquad.js";
+import { DebugLogger } from "../../common/utils.js";
 
 export class RetreatMission extends OneTimeMission {
-    constructor(uniqueName: string, priority: number, retreatToPoint: Point2D, unitIds: number[]) {
-        super(uniqueName, priority, () => new RetreatSquad(unitIds, retreatToPoint));
+    constructor(uniqueName: string, priority: number, retreatToPoint: Point2D, unitIds: number[], logger: DebugLogger) {
+        super(uniqueName, priority, () => new RetreatSquad(unitIds, retreatToPoint), logger);
     }
 }