@supalosa/chronodivide-bot 0.2.2 → 0.3.0

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

@@ -1,4 +1,4 @@
-import { GameApi, PlayerData, Point2D } from "@chronodivide/game-api";
+import { GameApi, GameMath, PlayerData, Vector2 } from "@chronodivide/game-api";
 import { Sector, SectorCache } from "../map/sector";
 import { DebugLogger } from "./utils";
 import { PriorityQueue } from "@datastructures-js/priority-queue";
@@ -14,14 +14,18 @@ export const getUnseenStartingLocations = (gameApi: GameApi, playerData: PlayerD
     return unseenStartingLocations;
 };
 
-class PrioritisedScoutTarget {
-    private _targetPoint2D?: Point2D;
+export class PrioritisedScoutTarget {
+    private _targetPoint?: Vector2;
     private _targetSector?: Sector;
     private _priority: number;
 
-    constructor(priority: number, target: Point2D | Sector) {
+    constructor(
+        priority: number,
+        target: Vector2 | Sector,
+        private permanent: boolean = false,
+    ) {
         if (target.hasOwnProperty("x") && target.hasOwnProperty("y")) {
-            this._targetPoint2D = target as Point2D;
+            this._targetPoint = target as Vector2;
         } else if (target.hasOwnProperty("sectorStartPoint")) {
             this._targetSector = target as Sector;
         } else {
@@ -34,49 +38,49 @@ class PrioritisedScoutTarget {
         return this._priority;
     }
 
-    asPoint2D() {
-        return this._targetPoint2D ?? this._targetSector?.sectorStartPoint ?? null;
+    asVector2() {
+        return this._targetPoint ?? this._targetSector?.sectorStartPoint ?? null;
     }
 
     get targetSector() {
         return this._targetSector;
     }
+
+    get isPermanent() {
+        return this.permanent;
+    }
 }
 
 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_STARTING_RADIUS = 2;
 const NEARBY_SECTOR_BASE_PRIORITY = 1000;
 
+// Amount of ticks per 'radius' to expand for scouting.
+const SCOUTING_RADIUS_EXPANSION_TICKS = 9000; // 10 minutes
+
 export class ScoutingManager {
     private scoutingQueue: PriorityQueue<PrioritisedScoutTarget>;
 
+    private queuedRadius = NEARBY_SECTOR_STARTING_RADIUS;
+
     constructor(private logger: DebugLogger) {
         // Order by descending priority.
-        this.scoutingQueue = new PriorityQueue((a: PrioritisedScoutTarget, b: PrioritisedScoutTarget) => b.priority - a.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();
+    addRadiusToScout(
+        gameApi: GameApi,
+        centerPoint: Vector2,
+        sectorCache: SectorCache,
+        radius: number,
+        startingPriority: number,
+    ) {
+        const { x: startX, y: startY } = centerPoint;
+        const { width: sectorsX, height: sectorsY } = sectorCache.getSectorBounds();
         const startingSector = sectorCache.getSectorCoordinatesForWorldPosition(startX, startY);
 
         if (!startingSector) {
@@ -84,24 +88,25 @@ export class ScoutingManager {
         }
 
         for (
-            let x: number = Math.max(0, startingSector.sectorX - NEARBY_SECTOR_RADIUS);
-            x <= Math.min(sectorsX, startingSector.sectorX + NEARBY_SECTOR_RADIUS);
+            let x: number = Math.max(0, startingSector.sectorX - radius);
+            x < Math.min(sectorsX, startingSector.sectorX + radius);
             ++x
         ) {
             for (
-                let y: number = Math.max(0, startingSector.sectorY - NEARBY_SECTOR_RADIUS);
-                y <= Math.min(sectorsY, startingSector.sectorY + NEARBY_SECTOR_RADIUS);
+                let y: number = Math.max(0, startingSector.sectorY - radius);
+                y < Math.min(sectorsY, startingSector.sectorY + 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 distanceFactor =
+                    GameMath.pow(x - startingSector.sectorX, 2) + GameMath.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();
+                    const maybeTarget = new PrioritisedScoutTarget(startingPriority - distanceFactor, sector);
+                    const maybePoint = maybeTarget.asVector2();
                     if (maybePoint && gameApi.mapApi.getTile(maybePoint.x, maybePoint.y)) {
                         this.scoutingQueue.enqueue(maybeTarget);
                     }
@@ -110,12 +115,39 @@ export class ScoutingManager {
         }
     }
 
-    onAiUpdate(gameApi: GameApi, playerData: PlayerData) {
+    onGameStart(gameApi: GameApi, playerData: PlayerData, sectorCache: SectorCache) {
+        // Queue hostile starting locations with high priority and as permanent scouting candidates.
+        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, true))
+            .forEach((target) => {
+                this.logger(`Adding ${target.asVector2()?.x},${target.asVector2()?.y} to initial scouting queue`);
+                this.scoutingQueue.enqueue(target);
+            });
+
+        // Queue sectors near the spawn point.
+        this.addRadiusToScout(
+            gameApi,
+            playerData.startLocation,
+            sectorCache,
+            NEARBY_SECTOR_STARTING_RADIUS,
+            NEARBY_SECTOR_BASE_PRIORITY,
+        );
+    }
+
+    onAiUpdate(gameApi: GameApi, playerData: PlayerData, sectorCache: SectorCache) {
         const currentHead = this.scoutingQueue.front();
         if (!currentHead) {
             return;
         }
-        const head = currentHead.asPoint2D();
+        const head = currentHead.asVector2();
         if (!head) {
             this.scoutingQueue.dequeue();
             return;
@@ -126,6 +158,19 @@ export class ScoutingManager {
             this.logger(`head point is visible, dequeueing`);
             this.scoutingQueue.dequeue();
         }
+
+        const requiredRadius = Math.floor(gameApi.getCurrentTick() / SCOUTING_RADIUS_EXPANSION_TICKS);
+        if (requiredRadius > this.queuedRadius) {
+            this.logger(`expanding scouting radius from ${this.queuedRadius} to ${requiredRadius}`);
+            this.addRadiusToScout(
+                gameApi,
+                playerData.startLocation,
+                sectorCache,
+                requiredRadius,
+                NEARBY_SECTOR_BASE_PRIORITY,
+            );
+            this.queuedRadius = requiredRadius;
+        }
     }
 
     getNewScoutTarget() {

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

@@ -1 +1,65 @@
-export type DebugLogger = (message: string, sayInGame?: boolean) => void;
+export type DebugLogger = (message: string, sayInGame?: boolean) => void;
+
+// Thanks use-strict!
+export function formatTimeDuration(timeSeconds: number, skipZeroHours = false) {
+    let h = Math.floor(timeSeconds / 3600);
+    timeSeconds -= h * 3600;
+    let m = Math.floor(timeSeconds / 60);
+    timeSeconds -= m * 60;
+    let s = Math.floor(timeSeconds);
+
+    return [...(h || !skipZeroHours ? [h] : []), pad(m, "00"), pad(s, "00")].join(":");
+}
+
+export function pad(n: any, format = "0000") {
+    let str = "" + n;
+    return format.substring(0, format.length - str.length) + str;
+}
+
+export function maxBy<T>(array: T[], predicate: (arg: T) => number | null): T | null {
+    if (array.length === 0) {
+        return null;
+    }
+    let maxIdx = 0;
+    let maxVal = predicate(array[0]);
+    for (let i = 1; i < array.length; ++i) {
+        const newVal = predicate(array[i]);
+        if (maxVal === null || (newVal !== null && newVal > maxVal)) {
+            maxIdx = i;
+            maxVal = newVal;
+        }
+    }
+    return array[maxIdx];
+}
+
+export function uniqBy<T>(array: T[], predicate: (arg: T) => string | number): T[] {
+    return Object.values(
+        array.reduce(
+            (prev, newVal) => {
+                const val = predicate(newVal);
+                if (!prev[val]) {
+                    prev[val] = newVal;
+                }
+                return prev;
+            },
+            {} as Record<string, T>,
+        ),
+    );
+}
+
+export function countBy<T>(array: T[], predicate: (arg: T) => string | undefined): { [key: string]: number } {
+    return array.reduce(
+        (prev, newVal) => {
+            const val = predicate(newVal);
+            if (val === undefined) {
+                return prev;
+            }
+            if (!prev[val]) {
+                prev[val] = 0;
+            }
+            prev[val] = prev[val] + 1;
+            return prev;
+        },
+        {} as Record<string, number>,
+    );
+}

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

@@ -1,27 +1,15 @@
-import { GameApi, MapApi, PlayerData, Point2D, Tile, UnitData } from "@chronodivide/game-api";
-import _ from "lodash";
+import { GameApi, GameMath, MapApi, PlayerData, Size, Tile, UnitData, Vector2 } from "@chronodivide/game-api";
+import { maxBy } from "../common/utils.js";
 
-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 determineMapBounds(mapApi: MapApi): Size {
+    return mapApi.getRealMapSize();
 }
 
 export function calculateAreaVisibility(
     mapApi: MapApi,
     playerData: PlayerData,
-    startPoint: Point2D,
-    endPoint: Point2D,
+    startPoint: Vector2,
+    endPoint: Vector2,
 ): { visibleTiles: number; validTiles: number } {
     let validTiles: number = 0,
         visibleTiles: number = 0;
@@ -42,29 +30,37 @@ export function calculateAreaVisibility(
 
 export function getPointTowardsOtherPoint(
     gameApi: GameApi,
-    startLocation: Point2D,
-    endLocation: Point2D,
+    startLocation: Vector2,
+    endLocation: Vector2,
     minRadius: number,
     maxRadius: number,
     randomAngle: number,
-): Point2D {
+): Vector2 {
+    // TODO: Use proper vector maths here.
     let radius = minRadius + Math.round(gameApi.generateRandom() * (maxRadius - minRadius));
-    let directionToSpawn = Math.atan2(endLocation.y - startLocation.y, endLocation.x - startLocation.x);
+    let directionToEndLocation = GameMath.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 };
+        directionToEndLocation -
+        (randomAngle * (Math.PI / 12) + 2 * randomAngle * gameApi.generateRandom() * (Math.PI / 12));
+    let candidatePointX = Math.round(startLocation.x + GameMath.cos(randomisedDirection) * radius);
+    let candidatePointY = Math.round(startLocation.y + GameMath.sin(randomisedDirection) * radius);
+    return new Vector2(candidatePointX, candidatePointY);
+}
+
+export function getDistanceBetweenPoints(startLocation: Vector2, endLocation: Vector2): number {
+    // TODO: Remove this now we have Vector2s.
+    return startLocation.distanceTo(endLocation);
 }
 
-export function getDistanceBetweenPoints(startLocation: Point2D, endLocation: Point2D): number {
-    return Math.sqrt((startLocation.x - endLocation.x) ** 2 + (startLocation.y - endLocation.y) ** 2);
+export function getDistanceBetweenTileAndPoint(tile: Tile, vector: Vector2): number {
+    // TODO: Remove this now we have Vector2s.
+    return new Vector2(tile.rx, tile.ry).distanceTo(vector);
 }
 
 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 });
+    return new Vector2(unit1.tile.rx, unit1.tile.ry).distanceTo(new Vector2(unit2.tile.rx, unit2.tile.ry));
 }
 
-export function getDistanceBetween(unit: UnitData, point: Point2D): number {
-    return getDistanceBetweenPoints({ x: unit.tile.rx, y: unit.tile.ry }, point);
+export function getDistanceBetween(unit: UnitData, point: Vector2): number {
+    return getDistanceBetweenPoints(new Vector2(unit.tile.rx, unit.tile.ry), point);
 }

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

@@ -1,6 +1,6 @@
 // A sector is a uniform-sized segment of the map.
 
-import { MapApi, PlayerData, Point2D, Tile } from "@chronodivide/game-api";
+import { MapApi, PlayerData, Size, Tile, Vector2 } from "@chronodivide/game-api";
 import { calculateAreaVisibility } from "./map.js";
 
 export const SECTOR_SIZE = 8;
@@ -11,7 +11,7 @@ export class Sector {
     private sectorLastExploredAt: number | undefined;
 
     constructor(
-        public sectorStartPoint: Point2D,
+        public sectorStartPoint: Vector2,
         public sectorStartTile: Tile | undefined,
         public sectorVisibilityPct: number | undefined,
         public sectorVisibilityLastCheckTick: number | undefined,
@@ -40,23 +40,25 @@ export class Sector {
 
 export class SectorCache {
     private sectors: Sector[][] = [];
-    private mapBounds: Point2D;
+    private mapBounds: Size;
     private sectorsX: number;
     private sectorsY: number;
     private lastUpdatedSectorX: number | undefined;
     private lastUpdatedSectorY: number | undefined;
 
-    constructor(mapApi: MapApi, mapBounds: Point2D) {
+    constructor(mapApi: MapApi, mapBounds: Size) {
         this.mapBounds = mapBounds;
-        this.sectorsX = Math.ceil(mapBounds.x / SECTOR_SIZE);
-        this.sectorsY = Math.ceil(mapBounds.y / SECTOR_SIZE);
+        this.sectorsX = Math.ceil(mapBounds.width / SECTOR_SIZE);
+        this.sectorsY = Math.ceil(mapBounds.height / SECTOR_SIZE);
         this.sectors = new Array(this.sectorsX);
         for (let xx = 0; xx < this.sectorsX; ++xx) {
             this.sectors[xx] = new Array(this.sectorsY);
             for (let yy = 0; yy < this.sectorsY; ++yy) {
+                const tileX = xx * SECTOR_SIZE;
+                const tileY = yy * SECTOR_SIZE;
                 this.sectors[xx][yy] = new Sector(
-                    { x: xx * SECTOR_SIZE, y: yy * SECTOR_SIZE },
-                    mapApi.getTile(xx * SECTOR_SIZE, yy * SECTOR_SIZE),
+                    new Vector2(tileX, tileY),
+                    mapApi.getTile(tileX, tileY),
                     undefined,
                     undefined,
                 );
@@ -64,7 +66,7 @@ export class SectorCache {
         }
     }
 
-    public getMapBounds(): Point2D {
+    public getMapBounds(): Size {
         return this.mapBounds;
     }
 
@@ -86,10 +88,7 @@ export class SectorCache {
             if (sector) {
                 sector.sectorVisibilityLastCheckTick = currentGameTick;
                 let sp = sector.sectorStartPoint;
-                let ep = {
-                    x: sector.sectorStartPoint.x + SECTOR_SIZE,
-                    y: sector.sectorStartPoint.y + SECTOR_SIZE,
-                };
+                let ep = new Vector2(sp.x + SECTOR_SIZE, sp.y + SECTOR_SIZE);
                 let visibility = calculateAreaVisibility(mapApi, playerData, sp, ep);
                 if (visibility.validTiles > 0) {
                     sector.sectorVisibilityPct = visibility.visibleTiles / visibility.validTiles;
@@ -151,21 +150,18 @@ export class SectorCache {
         return this.sectors[sectorX][sectorY];
     }
 
-    public getSectorBounds(): Point2D {
-        return {
-            x: this.sectorsX,
-            y: this.sectorsY,
-        }
+    public getSectorBounds(): Size {
+        return { width: this.sectorsX, height: this.sectorsY };
     }
 
     public getSectorCoordinatesForWorldPosition(x: number, y: number) {
-        if (x < 0 || x >= this.mapBounds.x || y < 0 || y >= this.mapBounds.y) {
+        if (x < 0 || x >= this.mapBounds.width || y < 0 || y >= this.mapBounds.height) {
             return undefined;
         }
         return {
             sectorX: Math.floor(x / SECTOR_SIZE),
-            sectorY: Math.floor(y / SECTOR_SIZE)
-        }
+            sectorY: Math.floor(y / SECTOR_SIZE),
+        };
     }
 
     public getSectorForWorldPosition(x: number, y: number): Sector | undefined {

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

@@ -7,6 +7,7 @@ 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;
@@ -46,4 +47,5 @@ export const createMissionFactories = () => [
     new ScoutingMissionFactory(),
     new AttackMissionFactory(),
     new DefenceMissionFactory(),
+    new EngineerMissionFactory(),
 ];

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

@@ -1,17 +1,12 @@
-import { AttackState, GameApi, ObjectType, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
-import { OneTimeMission } from "./oneTimeMission.js";
+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 { 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 { DebugLogger } from "../../common/utils.js";
+import { DebugLogger, maxBy } from "../../common/utils.js";
 
 export enum AttackFailReason {
     NoTargets = 0,
@@ -29,10 +24,10 @@ export class AttackMission extends Mission<AttackFailReason> {
     constructor(
         uniqueName: string,
         priority: number,
-        private rallyArea: Point2D,
-        private attackArea: Point2D,
+        private rallyArea: Vector2,
+        private attackArea: Vector2,
         private radius: number,
-        logger: DebugLogger
+        logger: DebugLogger,
     ) {
         super(uniqueName, priority, logger);
     }
@@ -81,7 +76,7 @@ export class AttackMissionFactory implements MissionFactory {
         return "AttackMissionFactory";
     }
 
-    generateTarget(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): Point2D | null {
+    generateTarget(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): Vector2 | null {
         // Randomly decide between harvester and base.
         try {
             const tryFocusHarvester = gameApi.generateRandomInt(0, 1) === 0;
@@ -90,9 +85,9 @@ 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 };
+                return new Vector2(maxUnit.tile.rx, maxUnit.tile.ry);
             }
         } catch (err) {
             // There's a crash here when accessing a building that got destroyed. Will catch and ignore or now.
@@ -106,7 +101,7 @@ export class AttackMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
-        logger: DebugLogger
+        logger: DebugLogger,
     ): void {
         if (!matchAwareness.shouldAttack()) {
             return;
@@ -128,19 +123,24 @@ export class AttackMissionFactory implements MissionFactory {
         const squadName = "globalAttack";
 
         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,
-                        ),
-                    );
-                },
-            ),
+            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

@@ -1,4 +1,4 @@
-import { GameApi, PlayerData, Point2D } from "@chronodivide/game-api";
+import { GameApi, PlayerData, Vector2 } from "@chronodivide/game-api";
 import { MatchAwareness } from "../../awareness.js";
 import { MissionController } from "../missionController.js";
 import { Mission, MissionAction, disbandMission, noop } from "../mission.js";
@@ -21,7 +21,7 @@ export class DefenceMission extends Mission<DefenceFailReason> {
     constructor(
         uniqueName: string,
         priority: number,
-        private defenceArea: Point2D,
+        private defenceArea: Vector2,
         private radius: number,
         logger: DebugLogger,
     ) {
@@ -46,7 +46,7 @@ export class DefenceMission extends Mission<DefenceFailReason> {
                         foundTargets.length
                     } found in area ${this.radius})`,
                 );
-                this.combatSquad?.setAttackArea({ x: foundTargets[0].x, y: foundTargets[0].y });
+                this.combatSquad?.setAttackArea(new Vector2(foundTargets[0].x, foundTargets[0].y));
             }
         }
         return noop();

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/retreatMission.ts

@@ -1,10 +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";
+import { Vector2 } from "@chronodivide/game-api";
 
 export class RetreatMission extends OneTimeMission {
-    constructor(uniqueName: string, priority: number, retreatToPoint: Point2D, unitIds: number[], logger: DebugLogger) {
+    constructor(uniqueName: string, priority: number, retreatToPoint: Vector2, unitIds: number[], logger: DebugLogger) {
         super(uniqueName, priority, () => new RetreatSquad(unitIds, retreatToPoint), logger);
     }
 }