@supalosa/chronodivide-bot 0.2.2-b → 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/map/map.ts

@@ -1,27 +1,15 @@
-import { GameApi, MapApi, PlayerData, Point2D, Tile, UnitData } from "@chronodivide/game-api";
+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/missions/attackMission.ts

@@ -1,4 +1,4 @@
-import { GameApi, ObjectType, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
+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";
@@ -24,8 +24,8 @@ 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,
     ) {
@@ -76,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;
@@ -87,7 +87,7 @@ export class AttackMissionFactory implements MissionFactory {
 
             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.

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

package/src/bot/logic/squad/behaviours/combatSquad.ts

@@ -1,4 +1,4 @@
-import { ActionsApi, GameApi, MovementZone, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
+import { ActionsApi, GameApi, GameMath, MovementZone, PlayerData, UnitData, Vector2 } from "@chronodivide/game-api";
 import { Squad } from "../squad.js";
 import { SquadAction, SquadBehaviour, grabCombatants, noop } from "../squadBehaviour.js";
 import { MatchAwareness } from "../../awareness.js";
@@ -36,12 +36,12 @@ export class CombatSquad implements SquadBehaviour {
      * @param radius
      */
     constructor(
-        private rallyArea: Point2D,
-        private targetArea: Point2D,
+        private rallyArea: Vector2,
+        private targetArea: Vector2,
         private radius: number,
     ) {}
 
-    public setAttackArea(targetArea: Point2D) {
+    public setAttackArea(targetArea: Vector2) {
         this.targetArea = targetArea;
     }
 
@@ -73,7 +73,7 @@ export class CombatSquad implements SquadBehaviour {
             );
 
             if (this.state === SquadState.Gathering) {
-                const requiredGatherRadius = Math.sqrt(groundUnits.length) * GATHER_RATIO + MIN_GATHER_RADIUS;
+                const requiredGatherRadius = GameMath.sqrt(groundUnits.length) * GATHER_RATIO + MIN_GATHER_RADIUS;
                 if (
                     centerOfMass &&
                     maxDistance &&
@@ -89,7 +89,7 @@ export class CombatSquad implements SquadBehaviour {
                 }
             } else {
                 const targetPoint = this.targetArea || playerData.startLocation;
-                const requiredGatherRadius = Math.sqrt(groundUnits.length) * GATHER_RATIO + MAX_GATHER_RADIUS;
+                const requiredGatherRadius = GameMath.sqrt(groundUnits.length) * GATHER_RATIO + MAX_GATHER_RADIUS;
                 if (
                     centerOfMass &&
                     maxDistance &&

package/src/bot/logic/squad/behaviours/common.ts

@@ -3,15 +3,15 @@ import {
     AttackState,
     ObjectType,
     OrderType,
-    Point2D,
     StanceType,
     UnitData,
+    Vector2,
     ZoneType,
 } from "@chronodivide/game-api";
 import { getDistanceBetweenPoints, getDistanceBetweenUnits } from "../../map/map.js";
 
 // Micro methods
-export function manageMoveMicro(actionsApi: ActionsApi, attacker: UnitData, attackPoint: Point2D) {
+export function manageMoveMicro(actionsApi: ActionsApi, attacker: UnitData, attackPoint: Vector2) {
     if (attacker.name === "E1") {
         const isDeployed = attacker.stance === StanceType.Deployed;
         if (isDeployed) {
@@ -65,5 +65,5 @@ export function getAttackWeight(attacker: UnitData, target: UnitData): number |
         return null;
     }
 
-    return 1000000 - getDistanceBetweenPoints({ x, y }, { x: hX, y: hY });
+    return 1000000 - getDistanceBetweenPoints(new Vector2(x, y), new Vector2(hX, hY));
 }

package/src/bot/logic/squad/behaviours/retreatSquad.ts

@@ -1,4 +1,4 @@
-import { ActionsApi, GameApi, OrderType, PlayerData, Point2D, SideType } from "@chronodivide/game-api";
+import { ActionsApi, GameApi, OrderType, PlayerData, Vector2 } from "@chronodivide/game-api";
 import { GlobalThreat } from "../../threat/threat.js";
 import { Squad } from "../squad.js";
 import { SquadAction, SquadBehaviour, disband, noop, requestSpecificUnits, requestUnits } from "../squadBehaviour.js";
@@ -11,7 +11,7 @@ export class RetreatSquad implements SquadBehaviour {
 
     constructor(
         private unitIds: number[],
-        private retreatToPoint: Point2D,
+        private retreatToPoint: Vector2,
     ) {}
 
     public onAiUpdate(

package/src/bot/logic/squad/behaviours/scoutingSquad.ts

@@ -1,9 +1,10 @@
-import { ActionsApi, GameApi, OrderType, PlayerData, Point2D } from "@chronodivide/game-api";
+import { ActionsApi, GameApi, OrderType, PlayerData, Vector2 } from "@chronodivide/game-api";
 import { Squad } from "../squad.js";
 import { SquadAction, SquadBehaviour, disband, noop, requestUnits } from "../squadBehaviour.js";
 import { MatchAwareness } from "../../awareness.js";
 import { DebugLogger } from "../../common/utils.js";
-import { getDistanceBetweenPoints } from "../../map/map.js";
+import { getDistanceBetweenTileAndPoint } from "../../map/map.js";
+import { PrioritisedScoutTarget } from "../../common/scout.js";
 
 const SCOUT_MOVE_COOLDOWN_TICKS = 30;
 
@@ -15,10 +16,11 @@ const MAX_ATTEMPTS_PER_TARGET = 5;
 const MAX_TICKS_PER_TARGET = 600;
 
 export class ScoutingSquad implements SquadBehaviour {
-    private scoutTarget: Point2D | null = null;
+    private scoutTarget: Vector2 | null = null;
     private attemptsOnCurrentTarget: number = 0;
     private scoutTargetRefreshedAt: number = 0;
     private lastMoveCommandTick: number = 0;
+    private scoutTargetIsPermanent: boolean = false;
 
     // Minimum distance from a scout to the target.
     private scoutMinDistance?: number;
@@ -49,17 +51,19 @@ export class ScoutingSquad implements SquadBehaviour {
             return requestUnits(scoutNames, 100);
         } else if (this.scoutTarget) {
             this.hadUnit = true;
-            if (this.attemptsOnCurrentTarget > MAX_ATTEMPTS_PER_TARGET) {
-                logger(
-                    `Scout target ${this.scoutTarget.x},${this.scoutTarget.y} took too many attempts, moving to next`,
-                );
-                this.setScoutTarget(null, 0);
-                return noop();
-            }
-            if (gameApi.getCurrentTick() > this.scoutTargetRefreshedAt + MAX_TICKS_PER_TARGET) {
-                logger(`Scout target ${this.scoutTarget.x},${this.scoutTarget.y} took too long, moving to next`);
-                this.setScoutTarget(null, 0);
-                return noop();
+            if (!this.scoutTargetIsPermanent) {
+                if (this.attemptsOnCurrentTarget > MAX_ATTEMPTS_PER_TARGET) {
+                    logger(
+                        `Scout target ${this.scoutTarget.x},${this.scoutTarget.y} took too many attempts, moving to next`,
+                    );
+                    this.setScoutTarget(null, 0);
+                    return noop();
+                }
+                if (gameApi.getCurrentTick() > this.scoutTargetRefreshedAt + MAX_TICKS_PER_TARGET) {
+                    logger(`Scout target ${this.scoutTarget.x},${this.scoutTarget.y} took too long, moving to next`);
+                    this.setScoutTarget(null, 0);
+                    return noop();
+                }
             }
             const targetTile = gameApi.mapApi.getTile(this.scoutTarget.x, this.scoutTarget.y);
             if (!targetTile) {
@@ -73,9 +77,7 @@ export class ScoutingSquad implements SquadBehaviour {
                     }
                 });
                 // Check that a scout is actually moving closer to the target.
-                const distances = scouts.map((unit) =>
-                    getDistanceBetweenPoints({ x: unit.tile.rx, y: unit.tile.ry }, this.scoutTarget!),
-                );
+                const distances = scouts.map((unit) => getDistanceBetweenTileAndPoint(unit.tile, this.scoutTarget!));
                 const newMinDistance = Math.min(...distances);
                 if (!this.scoutMinDistance || newMinDistance < this.scoutMinDistance) {
                     logger(
@@ -90,20 +92,21 @@ export class ScoutingSquad implements SquadBehaviour {
                 this.setScoutTarget(null, gameApi.getCurrentTick());
             }
         } else {
-            const candidatePoint = matchAwareness.getScoutingManager().getNewScoutTarget()?.asPoint2D();
-            if (!candidatePoint) {
+            const nextScoutTarget = matchAwareness.getScoutingManager().getNewScoutTarget();
+            if (!nextScoutTarget) {
                 logger(`No more scouting targets available, disbanding.`);
                 return disband();
             }
-            this.setScoutTarget(candidatePoint, gameApi.getCurrentTick());
+            this.setScoutTarget(nextScoutTarget, gameApi.getCurrentTick());
         }
         return noop();
     }
 
-    setScoutTarget(point: Point2D | null, currentTick: number) {
+    setScoutTarget(target: PrioritisedScoutTarget | null, currentTick: number) {
         this.attemptsOnCurrentTarget = 0;
         this.scoutTargetRefreshedAt = currentTick;
-        this.scoutTarget = point;
+        this.scoutTarget = target?.asVector2() ?? null;
         this.scoutMinDistance = undefined;
+        this.scoutTargetIsPermanent = target?.isPermanent ?? false;
     }
 }