@supalosa/chronodivide-bot 0.3.1 → 0.5.1

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

@@ -1,61 +1,196 @@
-import { GameApi, ObjectType, PlayerData, UnitData, Vector2 } from "@chronodivide/game-api";
-import { CombatSquad } from "../../squad/behaviours/combatSquad.js";
-import { Mission, MissionAction, disbandMission, noop } from "../mission.js";
-import { Squad } from "../../squad/squad.js";
+import { ActionsApi, GameApi, ObjectType, PlayerData, SideType, UnitData, Vector2 } from "@chronodivide/game-api";
+import { CombatSquad } from "./squads/combatSquad.js";
+import { Mission, MissionAction, disbandMission, noop, requestUnits } from "../mission.js";
 import { MissionFactory } from "../missionFactories.js";
 import { MatchAwareness } from "../../awareness.js";
 import { MissionController } from "../missionController.js";
 import { RetreatMission } from "./retreatMission.js";
-import { DebugLogger, maxBy } from "../../common/utils.js";
+import { DebugLogger, countBy, isOwnedByNeutral, maxBy } from "../../common/utils.js";
+import { ActionBatcher } from "../actionBatcher.js";
+import { getSovietComposition } from "../../composition/sovietCompositions.js";
+import { getAlliedCompositions } from "../../composition/alliedCompositions.js";
+import { UnitComposition } from "../../composition/common.js";
+import { manageMoveMicro } from "./squads/common.js";
 
 export enum AttackFailReason {
     NoTargets = 0,
     DefenceTooStrong = 1,
 }
 
-const NO_TARGET_IDLE_TIMEOUT_TICKS = 60;
+enum AttackMissionState {
+    Preparing = 0,
+    Attacking = 1,
+    Retreating = 2,
+}
+
+const NO_TARGET_RETARGET_TICKS = 450;
+const NO_TARGET_IDLE_TIMEOUT_TICKS = 900;
+
+function calculateTargetComposition(
+    gameApi: GameApi,
+    playerData: PlayerData,
+    matchAwareness: MatchAwareness,
+): UnitComposition {
+    if (!playerData.country) {
+        throw new Error(`player ${playerData.name} has no country`);
+    } else if (playerData.country.side === SideType.Nod) {
+        return getSovietComposition(gameApi, playerData, matchAwareness);
+    } else {
+        return getAlliedCompositions(gameApi, playerData, matchAwareness);
+    }
+}
+
+const ATTACK_MISSION_PRIORITY_RAMP = 1.01;
+const ATTACK_MISSION_MAX_PRIORITY = 50;
 
 /**
  * A mission that tries to attack a certain area.
  */
 export class AttackMission extends Mission<AttackFailReason> {
+    private squad: CombatSquad;
+
     private lastTargetSeenAt = 0;
+    private hasPickedNewTarget: boolean = false;
+
+    private state: AttackMissionState = AttackMissionState.Preparing;
 
     constructor(
         uniqueName: string,
-        priority: number,
-        private rallyArea: Vector2,
+        private priority: number,
+        rallyArea: Vector2,
         private attackArea: Vector2,
         private radius: number,
+        private composition: UnitComposition,
         logger: DebugLogger,
     ) {
-        super(uniqueName, priority, logger);
+        super(uniqueName, logger);
+        this.squad = new CombatSquad(rallyArea, attackArea, radius);
     }
 
-    onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
-        if (this.getSquad() === null) {
-            return this.setSquad(
-                new Squad(this.getUniqueName(), new CombatSquad(this.rallyArea, this.attackArea, this.radius), this),
+    _onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ): MissionAction {
+        switch (this.state) {
+            case AttackMissionState.Preparing:
+                return this.handlePreparingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher);
+            case AttackMissionState.Attacking:
+                return this.handleAttackingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher);
+            case AttackMissionState.Retreating:
+                return this.handleRetreatingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher);
+        }
+    }
+
+    private handlePreparingState(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ) {
+        const currentComposition: UnitComposition = countBy(this.getUnits(gameApi), (unit) => unit.name);
+
+        const missingUnits = Object.entries(this.composition).filter(([unitType, targetAmount]) => {
+            return !currentComposition[unitType] || currentComposition[unitType] < targetAmount;
+        });
+
+        if (missingUnits.length > 0) {
+            this.priority = Math.min(this.priority * ATTACK_MISSION_PRIORITY_RAMP, ATTACK_MISSION_MAX_PRIORITY);
+            return requestUnits(
+                missingUnits.map(([unitName]) => unitName),
+                this.priority,
             );
         } else {
-            // Dispatch missions.
-            if (!matchAwareness.shouldAttack()) {
-                return disbandMission(AttackFailReason.DefenceTooStrong);
-            }
+            this.priority = ATTACK_MISSION_INITIAL_PRIORITY;
+            this.state = AttackMissionState.Attacking;
+            return noop();
+        }
+    }
 
-            const foundTargets = matchAwareness.getHostilesNearPoint2d(this.attackArea, this.radius);
+    private handleAttackingState(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ) {
+        if (this.getUnitIds().length === 0) {
+            // TODO: disband directly (we no longer retreat when losing)
+            this.state = AttackMissionState.Retreating;
+            return noop();
+        }
+
+        const foundTargets = matchAwareness
+            .getHostilesNearPoint2d(this.attackArea, this.radius)
+            .map((unit) => gameApi.getUnitData(unit.unitId))
+            .filter((unit) => !isOwnedByNeutral(unit)) as UnitData[];
+
+        const update = this.squad.onAiUpdate(
+            gameApi,
+            actionsApi,
+            actionBatcher,
+            playerData,
+            this,
+            matchAwareness,
+            this.logger,
+        );
+
+        if (update.type !== "noop") {
+            return update;
+        }
 
-            if (foundTargets.length > 0) {
-                this.lastTargetSeenAt = gameApi.getCurrentTick();
-            } else if (gameApi.getCurrentTick() > this.lastTargetSeenAt + NO_TARGET_IDLE_TIMEOUT_TICKS) {
-                return disbandMission(AttackFailReason.NoTargets);
+        if (foundTargets.length > 0) {
+            this.lastTargetSeenAt = gameApi.getCurrentTick();
+            this.hasPickedNewTarget = false;
+        } else if (gameApi.getCurrentTick() > this.lastTargetSeenAt + NO_TARGET_IDLE_TIMEOUT_TICKS) {
+            return disbandMission(AttackFailReason.NoTargets);
+        } else if (
+            !this.hasPickedNewTarget &&
+            gameApi.getCurrentTick() > this.lastTargetSeenAt + NO_TARGET_RETARGET_TICKS
+        ) {
+            const newTarget = generateTarget(gameApi, playerData, matchAwareness);
+            if (newTarget) {
+                this.squad.setAttackArea(newTarget);
+                this.hasPickedNewTarget = true;
             }
         }
+
         return noop();
     }
-}
 
-const ATTACK_COOLDOWN_TICKS = 120;
+    private handleRetreatingState(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ) {
+        this.getUnits(gameApi).forEach((unitId) => {
+            actionBatcher.push(manageMoveMicro(unitId, matchAwareness.getMainRallyPoint()));
+        });
+        return disbandMission();
+    }
+
+    public getGlobalDebugText(): string | undefined {
+        return this.squad.getGlobalDebugText() ?? "<none>";
+    }
+
+    public getState() {
+        return this.state;
+    }
+
+    // This mission can give up its units while preparing.
+    public isUnitsLocked(): boolean {
+        return this.state !== AttackMissionState.Preparing;
+    }
+
+    public getPriority() {
+        return this.priority;
+    }
+}
 
 // Calculates the weight for initiating an attack on the position of a unit or building.
 // This is separate from unit micro; the squad will be ordered to attack in the vicinity of the point.
@@ -69,32 +204,64 @@ const getTargetWeight: (unitData: UnitData, tryFocusHarvester: boolean) => numbe
     }
 };
 
-export class AttackMissionFactory implements MissionFactory {
-    constructor(private lastAttackAt: number = -ATTACK_COOLDOWN_TICKS) {}
+function generateTarget(
+    gameApi: GameApi,
+    playerData: PlayerData,
+    matchAwareness: MatchAwareness,
+    includeBaseLocations: boolean = false,
+): Vector2 | null {
+    // Randomly decide between harvester and base.
+    try {
+        const tryFocusHarvester = gameApi.generateRandomInt(0, 1) === 0;
+        const enemyUnits = gameApi
+            .getVisibleUnits(playerData.name, "enemy")
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((u) => !!u && gameApi.getPlayerData(u.owner).isCombatant) as UnitData[];
 
-    getName(): string {
-        return "AttackMissionFactory";
-    }
+        const maxUnit = maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
+        if (maxUnit) {
+            return new Vector2(maxUnit.tile.rx, maxUnit.tile.ry);
+        }
+        if (includeBaseLocations) {
+            const mapApi = gameApi.mapApi;
+            const enemyPlayers = gameApi
+                .getPlayers()
+                .map(gameApi.getPlayerData)
+                .filter((otherPlayer) => !gameApi.areAlliedPlayers(playerData.name, otherPlayer.name));
 
-    generateTarget(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): Vector2 | null {
-        // Randomly decide between harvester and base.
-        try {
-            const tryFocusHarvester = gameApi.generateRandomInt(0, 1) === 0;
-            const enemyUnits = gameApi
-                .getVisibleUnits(playerData.name, "hostile")
-                .map((unitId) => gameApi.getUnitData(unitId))
-                .filter((u) => !!u && gameApi.getPlayerData(u.owner).isCombatant) as UnitData[];
-
-            const maxUnit = maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
-            if (maxUnit) {
-                return new Vector2(maxUnit.tile.rx, maxUnit.tile.ry);
+            const unexploredEnemyLocations = enemyPlayers.filter((otherPlayer) => {
+                const tile = mapApi.getTile(otherPlayer.startLocation.x, otherPlayer.startLocation.y);
+                if (!tile) {
+                    return false;
+                }
+                return !mapApi.isVisibleTile(tile, playerData.name);
+            });
+            if (unexploredEnemyLocations.length > 0) {
+                const idx = gameApi.generateRandomInt(0, unexploredEnemyLocations.length - 1);
+                return unexploredEnemyLocations[idx].startLocation;
             }
-        } catch (err) {
-            // There's a crash here when accessing a building that got destroyed. Will catch and ignore or now.
-            return null;
         }
+    } catch (err) {
+        // There's a crash here when accessing a building that got destroyed. Will catch and ignore or now.
         return null;
     }
+    return null;
+}
+
+// Number of ticks between attacking visible targets.
+const VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS = 120;
+
+// Number of ticks between attacking "bases" (enemy starting locations).
+const BASE_ATTACK_COOLDOWN_TICKS = 1800;
+
+const ATTACK_MISSION_INITIAL_PRIORITY = 1;
+
+export class AttackMissionFactory implements MissionFactory {
+    constructor(private lastAttackAt: number = -VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS) {}
+
+    getName(): string {
+        return "AttackMissionFactory";
+    }
 
     maybeCreateMissions(
         gameApi: GameApi,
@@ -103,40 +270,51 @@ export class AttackMissionFactory implements MissionFactory {
         missionController: MissionController,
         logger: DebugLogger,
     ): void {
-        if (!matchAwareness.shouldAttack()) {
+        if (gameApi.getCurrentTick() < this.lastAttackAt + VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS) {
             return;
         }
-        if (gameApi.getCurrentTick() < this.lastAttackAt + ATTACK_COOLDOWN_TICKS) {
+
+        // can only have one attack 'preparing' at once.
+        if (
+            missionController
+                .getMissions()
+                .some(
+                    (mission): mission is AttackMission =>
+                        mission instanceof AttackMission && mission.getState() === AttackMissionState.Preparing,
+                )
+        ) {
             return;
         }
 
-        const attackRadius = 15;
+        const attackRadius = 10;
 
-        const attackArea = this.generateTarget(gameApi, playerData, matchAwareness);
+        const includeEnemyBases = gameApi.getCurrentTick() > this.lastAttackAt + BASE_ATTACK_COOLDOWN_TICKS;
+
+        const attackArea = generateTarget(gameApi, playerData, matchAwareness, includeEnemyBases);
 
         if (!attackArea) {
-            // Nothing to attack.
             return;
         }
 
-        // TODO: not using a fixed value here. But performance slows to a crawl when this is unique.
-        const squadName = "globalAttack";
+        const squadName = "attack_" + gameApi.getCurrentTick();
+
+        const composition: UnitComposition = calculateTargetComposition(gameApi, playerData, matchAwareness);
 
         const tryAttack = missionController.addMission(
             new AttackMission(
                 squadName,
-                100,
+                ATTACK_MISSION_INITIAL_PRIORITY,
                 matchAwareness.getMainRallyPoint(),
                 attackArea,
                 attackRadius,
+                composition,
                 logger,
-            ).then((reason, squad) => {
+            ).then((unitIds, reason) => {
                 missionController.addMission(
                     new RetreatMission(
                         "retreat-from-" + squadName + gameApi.getCurrentTick(),
-                        100,
                         matchAwareness.getMainRallyPoint(),
-                        squad?.getUnitIds() ?? [],
+                        unitIds,
                         logger,
                     ),
                 );
@@ -151,7 +329,7 @@ export class AttackMissionFactory implements MissionFactory {
         gameApi: GameApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
-        failedMission: Mission,
+        failedMission: Mission<any>,
         failureReason: any,
         missionController: MissionController,
     ): void {}

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

@@ -1,55 +1,88 @@
-import { GameApi, PlayerData, Vector2 } from "@chronodivide/game-api";
+import { ActionsApi, GameApi, PlayerData, UnitData, Vector2 } from "@chronodivide/game-api";
 import { MatchAwareness } from "../../awareness.js";
 import { MissionController } from "../missionController.js";
-import { Mission, MissionAction, disbandMission, noop } from "../mission.js";
+import { Mission, MissionAction, grabCombatants, noop, releaseUnits, requestUnits } from "../mission.js";
 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";
+import { CombatSquad } from "./squads/combatSquad.js";
+import { DebugLogger, isOwnedByNeutral } from "../../common/utils.js";
+import { ActionBatcher } from "../actionBatcher.js";
 
-export enum DefenceFailReason {
-    NoTargets,
-}
+export const MAX_PRIORITY = 100;
+export const PRIORITY_INCREASE_PER_TICK_RATIO = 1.025;
 
 /**
  * A mission that tries to defend a certain area.
  */
-export class DefenceMission extends Mission<DefenceFailReason> {
-    private combatSquad?: CombatSquad;
+export class DefenceMission extends Mission<CombatSquad> {
+    private squad: CombatSquad;
 
     constructor(
         uniqueName: string,
-        priority: number,
+        private priority: number,
+        rallyArea: Vector2,
         private defenceArea: Vector2,
         private radius: number,
         logger: DebugLogger,
     ) {
-        super(uniqueName, priority, logger);
+        super(uniqueName, logger);
+        this.squad = new CombatSquad(rallyArea, defenceArea, radius);
     }
 
-    onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
-        if (this.getSquad() === null && !this.combatSquad) {
-            this.combatSquad = new CombatSquad(matchAwareness.getMainRallyPoint(), this.defenceArea, this.radius);
-            return this.setSquad(new Squad("defenceSquad-" + this.getUniqueName(), this.combatSquad, this));
-        } else {
-            // Dispatch missions.
-            const foundTargets = matchAwareness.getHostilesNearPoint2d(this.defenceArea, this.radius);
+    _onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ): MissionAction {
+        // Dispatch missions.
+        const foundTargets = matchAwareness
+            .getHostilesNearPoint2d(this.defenceArea, this.radius)
+            .map((unit) => gameApi.getUnitData(unit.unitId))
+            .filter((unit) => !isOwnedByNeutral(unit)) as UnitData[];
+
+        const update = this.squad.onAiUpdate(
+            gameApi,
+            actionsApi,
+            actionBatcher,
+            playerData,
+            this,
+            matchAwareness,
+            this.logger,
+        );
+
+        if (update.type !== "noop") {
+            return update;
+        }
 
-            if (foundTargets.length === 0) {
-                this.logger(`(Defence Mission ${this.getUniqueName()}): No targets found, disbanding.`);
-                return disbandMission(DefenceFailReason.NoTargets);
+        if (foundTargets.length === 0) {
+            this.priority = 0;
+            if (this.getUnitIds().length > 0) {
+                this.logger(`(Defence Mission ${this.getUniqueName()}): No targets found, releasing units.`);
+                return releaseUnits(this.getUnitIds());
             } 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(new Vector2(foundTargets[0].x, foundTargets[0].y));
+                return noop();
             }
+        } else {
+            const targetUnit = foundTargets[0];
+            this.logger(
+                `(Defence Mission ${this.getUniqueName()}): Focused on target ${targetUnit?.name} (${
+                    foundTargets.length
+                } found in area ${this.radius})`,
+            );
+            this.squad.setAttackArea(new Vector2(foundTargets[0].tile.rx, foundTargets[0].tile.ry));
+            this.priority = MAX_PRIORITY; // Math.min(MAX_PRIORITY, this.priority * PRIORITY_INCREASE_PER_TICK_RATIO);
+            return grabCombatants(playerData.startLocation, this.priority);
         }
-        return noop();
+        //return requestUnits(["E1", "E2", "FV", "HTK", "MTNK", "HTNK"], this.priority);
+    }
+
+    public getGlobalDebugText(): string | undefined {
+        return this.squad.getGlobalDebugText() ?? "<none>";
+    }
+
+    public getPriority() {
+        return this.priority;
     }
 }
 
@@ -83,7 +116,10 @@ export class DefenceMissionFactory implements MissionFactory {
 
         const defendableRadius =
             DEFENCE_STARTING_RADIUS + DEFENCE_RADIUS_INCREASE_PER_GAME_TICK * gameApi.getCurrentTick();
-        const enemiesNearSpawn = matchAwareness.getHostilesNearPoint2d(playerData.startLocation, defendableRadius);
+        const enemiesNearSpawn = matchAwareness
+            .getHostilesNearPoint2d(playerData.startLocation, defendableRadius)
+            .map((unit) => gameApi.getUnitData(unit.unitId))
+            .filter((unit) => !isOwnedByNeutral(unit)) as UnitData[];
 
         if (enemiesNearSpawn.length > 0) {
             logger(
@@ -94,21 +130,12 @@ export class DefenceMissionFactory implements MissionFactory {
             missionController.addMission(
                 new DefenceMission(
                     "globalDefence",
-                    1000,
+                    10,
+                    matchAwareness.getMainRallyPoint(),
                     playerData.startLocation,
                     defendableRadius * 1.2,
                     logger,
-                ).then((reason, squad) => {
-                    missionController.addMission(
-                        new RetreatMission(
-                            "retreat-from-globalDefence" + gameApi.getCurrentTick(),
-                            100,
-                            matchAwareness.getMainRallyPoint(),
-                            squad?.getUnitIds() ?? [],
-                            logger,
-                        ),
-                    );
-                }),
+                ),
             );
         }
     }
@@ -117,7 +144,7 @@ export class DefenceMissionFactory implements MissionFactory {
         gameApi: GameApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
-        failedMission: Mission,
+        failedMission: Mission<any>,
         failureReason: undefined,
         missionController: MissionController,
     ): void {}

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

@@ -1,21 +1,70 @@
-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 { ActionsApi, GameApi, OrderType, PlayerData } from "@chronodivide/game-api";
+import { Mission, MissionAction, disbandMission, noop, requestUnits } from "../mission.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";
+import { ActionBatcher } from "../actionBatcher.js";
+
+const CAPTURE_COOLDOWN_TICKS = 30;
 
 /**
  * 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);
+export class EngineerMission extends Mission {
+    private hasAttemptedCaptureWith: {
+        unitId: number;
+        gameTick: number;
+    } | null = null;
+
+    constructor(
+        uniqueName: string,
+        private priority: number,
+        private captureTargetId: number,
+        logger: DebugLogger,
+    ) {
+        super(uniqueName, logger);
+    }
+
+    public _onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ): MissionAction {
+        const engineerTypes = ["ENGINEER", "SENGINEER"];
+        const engineers = this.getUnitsOfTypes(gameApi, ...engineerTypes);
+        if (engineers.length === 0) {
+            // Perhaps we deployed already (or the unit was destroyed), end the mission.
+            if (this.hasAttemptedCaptureWith !== null) {
+                return disbandMission();
+            }
+            return requestUnits(engineerTypes, this.priority);
+        } else if (
+            !this.hasAttemptedCaptureWith ||
+            gameApi.getCurrentTick() > this.hasAttemptedCaptureWith.gameTick + CAPTURE_COOLDOWN_TICKS
+        ) {
+            actionsApi.orderUnits(
+                engineers.map((engineer) => engineer.id),
+                OrderType.Capture,
+                this.captureTargetId,
+            );
+            // Add a cooldown to deploy attempts.
+            this.hasAttemptedCaptureWith = {
+                unitId: engineers[0].id,
+                gameTick: gameApi.getCurrentTick(),
+            };
+        }
+        return noop();
+    }
+
+    public getGlobalDebugText(): string | undefined {
+        return undefined;
+    }
+
+    public getPriority() {
+        return this.priority;
     }
 }
 
@@ -36,13 +85,17 @@ export class EngineerMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
-        logger: DebugLogger
+        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);
+        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));
@@ -53,9 +106,8 @@ export class EngineerMissionFactory implements MissionFactory {
         gameApi: GameApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
-        failedMission: Mission,
+        failedMission: Mission<any>,
         failureReason: undefined,
         missionController: MissionController,
-    ): void {
-    }
+    ): void {}
 }