@supalosa/chronodivide-bot 0.4.0 → 0.5.2

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

@@ -1,20 +1,74 @@
-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, requestSpecificUnits, 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 { ActionBatcher } from "../actionBatcher.js";
+
+const DEPLOY_COOLDOWN_TICKS = 30;
 
 /**
  * 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, 
-        logger: DebugLogger) {
-        super(uniqueName, priority, () => new ExpansionSquad(selectedMcv), logger);
+export class ExpansionMission extends Mission {
+    private hasAttemptedDeployWith: {
+        unitId: number;
+        gameTick: number;
+    } | null = null;
+
+    constructor(
+        uniqueName: string,
+        private priority: number,
+        private selectedMcv: number | null,
+        logger: DebugLogger,
+    ) {
+        super(uniqueName, logger);
+    }
+
+    public _onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ): MissionAction {
+        const mcvTypes = ["AMCV", "SMCV"];
+        const mcvs = this.getUnitsOfTypes(gameApi, ...mcvTypes);
+        if (mcvs.length === 0) {
+            // Perhaps we deployed already (or the unit was destroyed), end the mission.
+            if (this.hasAttemptedDeployWith !== null) {
+                return disbandMission();
+            }
+            // We need an mcv!
+            if (this.selectedMcv) {
+                return requestSpecificUnits([this.selectedMcv], this.priority);
+            } else {
+                return requestUnits(mcvTypes, this.priority);
+            }
+        } else if (
+            !this.hasAttemptedDeployWith ||
+            gameApi.getCurrentTick() > this.hasAttemptedDeployWith.gameTick + DEPLOY_COOLDOWN_TICKS
+        ) {
+            actionsApi.orderUnits(
+                mcvs.map((mcv) => mcv.id),
+                OrderType.DeploySelected,
+            );
+            // Add a cooldown to deploy attempts.
+            this.hasAttemptedDeployWith = {
+                unitId: mcvs[0].id,
+                gameTick: gameApi.getCurrentTick(),
+            };
+        }
+        return noop();
+    }
+
+    public getGlobalDebugText(): string | undefined {
+        return `Expand with MCV ${this.selectedMcv}`;
+    }
+
+    public getPriority() {
+        return this.priority;
     }
 }
 
@@ -28,11 +82,11 @@ export class ExpansionMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
-        logger: DebugLogger
+        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)
+            gameApi.getGeneralRules().baseUnit.includes(r.name),
         );
         mcvs.forEach((mcv) => {
             missionController.addMission(new ExpansionMission("expand-with-" + mcv, 100, mcv, logger));
@@ -43,9 +97,8 @@ export class ExpansionMissionFactory implements MissionFactory {
         gameApi: GameApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
-        failedMission: Mission,
+        failedMission: Mission<any>,
         failureReason: undefined,
         missionController: MissionController,
-    ): void {
-    }
+    ): void {}
 }

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

@@ -1,10 +1,54 @@
-import { OneTimeMission } from "./oneTimeMission.js";
-import { RetreatSquad } from "../../squad/behaviours/retreatSquad.js";
 import { DebugLogger } from "../../common/utils.js";
-import { Vector2 } from "@chronodivide/game-api";
+import { ActionsApi, GameApi, OrderType, PlayerData, Vector2 } from "@chronodivide/game-api";
+import { Mission, MissionAction, disbandMission, requestSpecificUnits } from "../mission.js";
+import { ActionBatcher } from "../actionBatcher.js";
+import { MatchAwareness } from "../../awareness.js";
 
-export class RetreatMission extends OneTimeMission {
-    constructor(uniqueName: string, priority: number, retreatToPoint: Vector2, unitIds: number[], logger: DebugLogger) {
-        super(uniqueName, priority, () => new RetreatSquad(unitIds, retreatToPoint), logger);
+export class RetreatMission extends Mission {
+    private createdAt: number | null = null;
+
+    constructor(
+        uniqueName: string,
+        private retreatToPoint: Vector2,
+        private withUnitIds: number[],
+        logger: DebugLogger,
+    ) {
+        super(uniqueName, logger);
+    }
+
+    public _onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ): MissionAction {
+        if (!this.createdAt) {
+            this.createdAt = gameApi.getCurrentTick();
+        }
+        if (this.getUnitIds().length > 0) {
+            // Only send the order once we have managed to claim some units.
+            actionsApi.orderUnits(
+                this.getUnitIds(),
+                OrderType.AttackMove,
+                this.retreatToPoint.x,
+                this.retreatToPoint.y,
+            );
+            return disbandMission();
+        }
+        if (this.createdAt && gameApi.getCurrentTick() > this.createdAt + 240) {
+            // Disband automatically after 240 ticks in case we couldn't actually claim any units.
+            return disbandMission();
+        } else {
+            return requestSpecificUnits(this.withUnitIds, 1000);
+        }
+    }
+
+    public getGlobalDebugText(): string | undefined {
+        return `retreat with ${this.withUnitIds.length} units`;
+    }
+
+    public getPriority() {
+        return 100;
     }
 }

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

@@ -1,21 +1,138 @@
-import { GameApi, PlayerData } from "@chronodivide/game-api";
-import { ScoutingSquad } from "../../squad/behaviours/scoutingSquad.js";
+import { ActionsApi, GameApi, OrderType, PlayerData, Vector2 } from "@chronodivide/game-api";
 import { MissionFactory } from "../missionFactories.js";
-import { OneTimeMission } from "./oneTimeMission.js";
 import { MatchAwareness } from "../../awareness.js";
-import { Mission } from "../mission.js";
+import { Mission, MissionAction, disbandMission, noop, requestUnits } from "../mission.js";
 import { AttackMission } from "./attackMission.js";
 import { MissionController } from "../missionController.js";
-import { getUnseenStartingLocations } from "../../common/scout.js";
 import { DebugLogger } from "../../common/utils.js";
+import { ActionBatcher } from "../actionBatcher.js";
+import { getDistanceBetweenTileAndPoint } from "../../map/map.js";
+import { PrioritisedScoutTarget } from "../../common/scout.js";
+
+const SCOUT_MOVE_COOLDOWN_TICKS = 30;
+
+// Max units to spend on a particular scout target.
+const MAX_ATTEMPTS_PER_TARGET = 5;
+
+// Maximum ticks to spend trying to scout a target *without making progress towards it*.
+// Every time a unit gets closer to the target, the timer refreshes.
+const MAX_TICKS_PER_TARGET = 600;
 
 /**
  * A mission that tries to scout around the map with a cheap, fast unit (usually attack dogs)
  */
-export class ScoutingMission extends OneTimeMission {
-    constructor(uniqueName: string, priority: number, 
-        logger: DebugLogger) {
-        super(uniqueName, priority, () => new ScoutingSquad(), logger);
+export class ScoutingMission extends Mission {
+    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;
+
+    private hadUnit: boolean = false;
+
+    constructor(
+        uniqueName: string,
+        private priority: number,
+        logger: DebugLogger,
+    ) {
+        super(uniqueName, logger);
+    }
+
+    public _onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ): MissionAction {
+        const scoutNames = ["ADOG", "DOG", "E1", "E2", "FV", "HTK"];
+        const scouts = this.getUnitsOfTypes(gameApi, ...scoutNames);
+
+        if ((matchAwareness.getSectorCache().getOverallVisibility() || 0) > 0.9) {
+            return disbandMission();
+        }
+
+        if (scouts.length === 0) {
+            // Count the number of times the scout dies trying to uncover the current scoutTarget.
+            if (this.scoutTarget && this.hadUnit) {
+                this.attemptsOnCurrentTarget++;
+                this.hadUnit = false;
+            }
+            return requestUnits(scoutNames, this.priority);
+        } else if (this.scoutTarget) {
+            this.hadUnit = true;
+            if (!this.scoutTargetIsPermanent) {
+                if (this.attemptsOnCurrentTarget > MAX_ATTEMPTS_PER_TARGET) {
+                    this.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) {
+                    this.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) {
+                throw new Error(`target tile ${this.scoutTarget.x},${this.scoutTarget.y} does not exist`);
+            }
+            if (gameApi.getCurrentTick() > this.lastMoveCommandTick + SCOUT_MOVE_COOLDOWN_TICKS) {
+                this.lastMoveCommandTick = gameApi.getCurrentTick();
+                scouts.forEach((unit) => {
+                    if (this.scoutTarget) {
+                        actionsApi.orderUnits([unit.id], OrderType.AttackMove, this.scoutTarget.x, this.scoutTarget.y);
+                    }
+                });
+                // Check that a scout is actually moving closer to the target.
+                const distances = scouts.map((unit) => getDistanceBetweenTileAndPoint(unit.tile, this.scoutTarget!));
+                const newMinDistance = Math.min(...distances);
+                if (!this.scoutMinDistance || newMinDistance < this.scoutMinDistance) {
+                    this.logger(
+                        `Scout timeout refreshed because unit moved closer to point (${newMinDistance} < ${this.scoutMinDistance})`,
+                    );
+                    this.scoutTargetRefreshedAt = gameApi.getCurrentTick();
+                    this.scoutMinDistance = newMinDistance;
+                }
+            }
+            if (gameApi.mapApi.isVisibleTile(targetTile, playerData.name)) {
+                this.logger(
+                    `Scout target ${this.scoutTarget.x},${this.scoutTarget.y} successfully scouted, moving to next`,
+                );
+                this.setScoutTarget(null, gameApi.getCurrentTick());
+            }
+        } else {
+            const nextScoutTarget = matchAwareness.getScoutingManager().getNewScoutTarget();
+            if (!nextScoutTarget) {
+                this.logger(`No more scouting targets available, disbanding.`);
+                return disbandMission();
+            }
+            this.setScoutTarget(nextScoutTarget, gameApi.getCurrentTick());
+        }
+        return noop();
+    }
+
+    setScoutTarget(target: PrioritisedScoutTarget | null, currentTick: number) {
+        this.attemptsOnCurrentTarget = 0;
+        this.scoutTargetRefreshedAt = currentTick;
+        this.scoutTarget = target?.asVector2() ?? null;
+        this.scoutMinDistance = undefined;
+        this.scoutTargetIsPermanent = target?.isPermanent ?? false;
+    }
+
+    public getGlobalDebugText(): string | undefined {
+        return "scouting";
+    }
+
+    public getPriority() {
+        return this.priority;
     }
 }
 
@@ -33,7 +150,7 @@ export class ScoutingMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
-        logger: DebugLogger
+        logger: DebugLogger,
     ): void {
         if (gameApi.getCurrentTick() < this.lastScoutAt + SCOUT_COOLDOWN_TICKS) {
             return;
@@ -41,7 +158,7 @@ export class ScoutingMissionFactory implements MissionFactory {
         if (!matchAwareness.getScoutingManager().hasScoutTargets()) {
             return;
         }
-        if (!missionController.addMission(new ScoutingMission("globalScout", 100, logger))) {
+        if (!missionController.addMission(new ScoutingMission("globalScout", 10, logger))) {
             this.lastScoutAt = gameApi.getCurrentTick();
         }
     }
@@ -50,13 +167,20 @@ export class ScoutingMissionFactory implements MissionFactory {
         gameApi: GameApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
-        failedMission: Mission,
+        failedMission: Mission<any>,
         failureReason: undefined,
         missionController: MissionController,
-        logger: DebugLogger
+        logger: DebugLogger,
     ): void {
+        if (gameApi.getCurrentTick() < this.lastScoutAt + SCOUT_COOLDOWN_TICKS) {
+            return;
+        }
+        if (!matchAwareness.getScoutingManager().hasScoutTargets()) {
+            return;
+        }
         if (failedMission instanceof AttackMission) {
-            missionController.addMission(new ScoutingMission("globalScout", 100, logger));
+            missionController.addMission(new ScoutingMission("globalScout", 10, logger));
+            this.lastScoutAt = gameApi.getCurrentTick();
         }
     }
 }

package/src/bot/logic/{squad/behaviours → mission/missions/squads}/combatSquad.ts

@@ -1,15 +1,21 @@
-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";
+import {
+    ActionsApi,
+    AttackState,
+    GameApi,
+    GameMath,
+    MovementZone,
+    PlayerData,
+    UnitData,
+    Vector2,
+} from "@chronodivide/game-api";
+import { MatchAwareness } from "../../../awareness.js";
 import { getAttackWeight, manageAttackMicro, manageMoveMicro } from "./common.js";
-import { DebugLogger, maxBy } from "../../common/utils.js";
-import { ActionBatcher } from "./actionBatcher.js";
+import { DebugLogger, isOwnedByNeutral, maxBy, minBy } from "../../../common/utils.js";
+import { ActionBatcher, BatchableAction } from "../../actionBatcher.js";
+import { Squad } from "./squad.js";
+import { Mission, MissionAction, grabCombatants, noop } from "../../mission.js";
 
 const TARGET_UPDATE_INTERVAL_TICKS = 10;
-const GRAB_INTERVAL_TICKS = 10;
-
-const GRAB_RADIUS = 20;
 
 // Units must be in a certain radius of the center of mass before attacking.
 // This scales for number of units in the squad though.
@@ -20,18 +26,21 @@ const MAX_GATHER_RADIUS = 15;
 
 const GATHER_RATIO = 10;
 
+const ATTACK_SCAN_AREA = 15;
+
 enum SquadState {
     Gathering,
     Attacking,
 }
 
-export class CombatSquad implements SquadBehaviour {
-    private lastGrab: number | null = null;
+export class CombatSquad implements Squad {
     private lastCommand: number | null = null;
     private state = SquadState.Gathering;
 
     private debugLastTarget: string | undefined;
 
+    private lastOrderGiven: { [unitId: number]: BatchableAction } = {};
+
     /**
      *
      * @param rallyArea the initial location to grab combatants
@@ -57,21 +66,21 @@ export class CombatSquad implements SquadBehaviour {
         actionsApi: ActionsApi,
         actionBatcher: ActionBatcher,
         playerData: PlayerData,
-        squad: Squad,
+        mission: Mission<any>,
         matchAwareness: MatchAwareness,
         logger: DebugLogger,
-    ): SquadAction {
+    ): MissionAction {
         if (
-            squad.getUnitIds().length > 0 &&
+            mission.getUnitIds().length > 0 &&
             (!this.lastCommand || gameApi.getCurrentTick() > this.lastCommand + TARGET_UPDATE_INTERVAL_TICKS)
         ) {
             this.lastCommand = gameApi.getCurrentTick();
-            const centerOfMass = squad.getCenterOfMass();
-            const maxDistance = squad.getMaxDistanceToCenterOfMass();
-            const units = squad.getUnitsMatching(gameApi, (r) => r.rules.isSelectableCombatant);
+            const centerOfMass = mission.getCenterOfMass();
+            const maxDistance = mission.getMaxDistanceToCenterOfMass();
+            const units = mission.getUnitsMatching(gameApi, (r) => r.rules.isSelectableCombatant);
 
             // Only use ground units for center of mass.
-            const groundUnits = squad.getUnitsMatching(
+            const groundUnits = mission.getUnitsMatching(
                 gameApi,
                 (r) =>
                     r.rules.isSelectableCombatant &&
@@ -89,10 +98,10 @@ export class CombatSquad implements SquadBehaviour {
                     maxDistance > requiredGatherRadius
                 ) {
                     units.forEach((unit) => {
-                        actionBatcher.push(manageMoveMicro(unit, centerOfMass));
+                        this.submitActionIfNew(actionBatcher, manageMoveMicro(unit, centerOfMass));
                     });
                 } else {
-                    logger(`CombatSquad ${squad.getName()} switching back to attack mode (${maxDistance})`);
+                    logger(`CombatSquad ${mission.getUniqueName()} switching back to attack mode (${maxDistance})`);
                     this.state = SquadState.Attacking;
                 }
             } else {
@@ -105,33 +114,47 @@ export class CombatSquad implements SquadBehaviour {
                     maxDistance > requiredGatherRadius
                 ) {
                     // Switch back to gather mode
-                    logger(`CombatSquad ${squad.getName()} switching back to gather (${maxDistance})`);
+                    logger(`CombatSquad ${mission.getUniqueName()} switching back to gather (${maxDistance})`);
                     this.state = SquadState.Gathering;
                     return noop();
                 }
+                // The unit with the shortest range chooses the target. Otherwise, a base range of 5 is chosen.
+                const getRangeForUnit = (unit: UnitData) =>
+                    unit.primaryWeapon?.maxRange ?? unit.secondaryWeapon?.maxRange ?? 5;
+                const attackLeader = minBy(units, getRangeForUnit);
+                if (!attackLeader) {
+                    return noop();
+                }
+                // Find units within double the range of the leader.
+                const nearbyHostiles = matchAwareness
+                    .getHostilesNearPoint(attackLeader.tile.rx, attackLeader.tile.ry, ATTACK_SCAN_AREA)
+                    .map(({ unitId }) => gameApi.getUnitData(unitId))
+                    .filter((unit) => !isOwnedByNeutral(unit)) as UnitData[];
+
                 for (const unit of units) {
-                    const { rx: x, ry: y } = unit.tile;
-                    const range = unit.primaryWeapon?.maxRange ?? unit.secondaryWeapon?.maxRange ?? 5;
-                    const nearbyHostiles = matchAwareness
-                        .getHostilesNearPoint(x, y, range * 2)
-                        .map(({ unitId }) => gameApi.getUnitData(unitId)) as UnitData[];
                     const bestUnit = maxBy(nearbyHostiles, (target) => getAttackWeight(unit, target));
                     if (bestUnit) {
-                        actionBatcher.push(manageAttackMicro(unit, bestUnit));
+                        this.submitActionIfNew(actionBatcher, manageAttackMicro(unit, bestUnit));
                         this.debugLastTarget = `Unit ${bestUnit.id.toString()}`;
                     } else {
-                        actionBatcher.push(manageMoveMicro(unit, targetPoint));
+                        this.submitActionIfNew(actionBatcher, manageMoveMicro(unit, targetPoint));
                         this.debugLastTarget = `@${targetPoint.x},${targetPoint.y}`;
                     }
                 }
             }
         }
+        return noop();
+    }
 
-        if (!this.lastGrab || gameApi.getCurrentTick() > this.lastGrab + GRAB_INTERVAL_TICKS) {
-            this.lastGrab = gameApi.getCurrentTick();
-            return grabCombatants(squad.getCenterOfMass() ?? this.rallyArea, GRAB_RADIUS);
-        } else {
-            return noop();
+    /**
+     * Sends an action to the acitonBatcher if and only if the action is different from the last action we submitted to it.
+     * Prevents spamming redundant orders, which affects performance and can also ccause the unit to sit around doing nothing.
+     */
+    private submitActionIfNew(actionBatcher: ActionBatcher, action: BatchableAction) {
+        const lastAction = this.lastOrderGiven[action.unitId];
+        if (!lastAction || !lastAction.isSameAs(action)) {
+            actionBatcher.push(action);
+            this.lastOrderGiven[action.unitId] = action;
         }
     }
 }

package/src/bot/logic/{squad/behaviours → mission/missions/squads}/common.ts

@@ -1,26 +1,20 @@
-import {
-    ActionsApi,
-    AttackState,
-    ObjectType,
-    OrderType,
-    StanceType,
-    UnitData,
-    Vector2,
-    ZoneType,
-} from "@chronodivide/game-api";
-import { getDistanceBetweenPoints, getDistanceBetweenUnits } from "../../map/map.js";
-import { BatchableAction } from "./actionBatcher.js";
+import { AttackState, ObjectType, OrderType, StanceType, UnitData, Vector2, ZoneType } from "@chronodivide/game-api";
+import { getDistanceBetweenPoints, getDistanceBetweenUnits } from "../../../map/map.js";
+import { BatchableAction } from "../../actionBatcher.js";
+
+const NONCE_GI_DEPLOY = 0;
+const NONCE_GI_UNDEPLOY = 1;
 
 // Micro methods
 export function manageMoveMicro(attacker: UnitData, attackPoint: Vector2): BatchableAction {
     if (attacker.name === "E1") {
         const isDeployed = attacker.stance === StanceType.Deployed;
         if (isDeployed) {
-            return { unitId: attacker.id, orderType: OrderType.DeploySelected };
+            return BatchableAction.noTarget(attacker.id, OrderType.DeploySelected, NONCE_GI_UNDEPLOY);
         }
     }
 
-    return { unitId: attacker.id, orderType: OrderType.Move, point: attackPoint };
+    return BatchableAction.toPoint(attacker.id, OrderType.AttackMove, attackPoint);
 }
 
 export function manageAttackMicro(attacker: UnitData, target: UnitData): BatchableAction {
@@ -30,9 +24,9 @@ export function manageAttackMicro(attacker: UnitData, target: UnitData): Batchab
         const deployedWeaponRange = attacker.secondaryWeapon?.maxRange || 5;
         const isDeployed = attacker.stance === StanceType.Deployed;
         if (!isDeployed && (distance <= deployedWeaponRange || attacker.attackState === AttackState.JustFired)) {
-            return { unitId: attacker.id, orderType: OrderType.DeploySelected };
+            return BatchableAction.noTarget(attacker.id, OrderType.DeploySelected, NONCE_GI_DEPLOY);
         } else if (isDeployed && distance > deployedWeaponRange) {
-            return { unitId: attacker.id, orderType: OrderType.DeploySelected };
+            return BatchableAction.noTarget(attacker.id, OrderType.DeploySelected, NONCE_GI_UNDEPLOY);
         }
     }
     let targetData = target;
@@ -44,7 +38,7 @@ export function manageAttackMicro(attacker: UnitData, target: UnitData): Batchab
         // Special case for mirage tank/spy as otherwise they just sit next to it.
         orderType = OrderType.Attack;
     }
-    return { unitId: attacker.id, orderType, targetId: target.id };
+    return BatchableAction.toTargetId(attacker.id, orderType, target.id);
 }
 
 /**

package/src/bot/logic/mission/missions/squads/squad.ts

@@ -0,0 +1,19 @@
+import { ActionsApi, GameApi, PlayerData } from "@chronodivide/game-api";
+import { ActionBatcher } from "../../actionBatcher";
+import { Mission, MissionAction } from "../../mission";
+import { MatchAwareness } from "../../../awareness";
+import { DebugLogger } from "../../../common/utils";
+
+export interface Squad {
+    onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        actionBatcher: ActionBatcher,
+        playerData: PlayerData,
+        mission: Mission<any>,
+        matchAwareness: MatchAwareness,
+        logger: DebugLogger,
+    ): MissionAction;
+
+    getGlobalDebugText(): string | undefined;
+}

package/src/bot/logic/threat/threatCalculator.ts

@@ -4,25 +4,25 @@ import { GlobalThreat } from "./threat.js";
 export function calculateGlobalThreat(game: GameApi, playerData: PlayerData, visibleAreaPercent: number): GlobalThreat {
     let groundUnits = game.getVisibleUnits(
         playerData.name,
-        "hostile",
+        "enemy",
         (r) => r.type == ObjectType.Vehicle || r.type == ObjectType.Infantry,
     );
-    let airUnits = game.getVisibleUnits(playerData.name, "hostile", (r) => r.movementZone == MovementZone.Fly);
+    let airUnits = game.getVisibleUnits(playerData.name, "enemy", (r) => r.movementZone == MovementZone.Fly);
     let groundDefence = game
-        .getVisibleUnits(playerData.name, "hostile", (r) => r.type == ObjectType.Building)
+        .getVisibleUnits(playerData.name, "enemy", (r) => r.type == ObjectType.Building)
         .filter((unitId) => isAntiGround(game, unitId));
     let antiAirPower = game
-        .getVisibleUnits(playerData.name, "hostile", (r) => r.type != ObjectType.Building)
+        .getVisibleUnits(playerData.name, "enemy", (r) => r.type != ObjectType.Building)
         .filter((unitId) => isAntiAir(game, unitId));
 
     let ourAntiGroundUnits = game
         .getVisibleUnits(playerData.name, "self", (r) => r.isSelectableCombatant)
         .filter((unitId) => isAntiGround(game, unitId));
     let ourAntiAirUnits = game
-        .getVisibleUnits(playerData.name, "self", (r) => r.isSelectableCombatant)
+        .getVisibleUnits(playerData.name, "self", (r) => r.isSelectableCombatant || r.type === ObjectType.Building)
         .filter((unitId) => isAntiAir(game, unitId));
     let ourGroundDefence = game
-        .getVisibleUnits(playerData.name, "self", (r) => r.type == ObjectType.Building)
+        .getVisibleUnits(playerData.name, "self", (r) => r.type === ObjectType.Building)
         .filter((unitId) => isAntiGround(game, unitId));
     let ourAirUnits = game.getVisibleUnits(
         playerData.name,
@@ -45,8 +45,8 @@ export function calculateGlobalThreat(game: GameApi, playerData: PlayerData, vis
         observedGroundThreat,
         observedAirThreat,
         observedAntiAirThreat,
-        observedGroundDefence * 0.25,
-        ourGroundDefencePower * 0.25,
+        observedGroundDefence,
+        ourGroundDefencePower,
         ourAntiGroundPower,
         ourAntiAirPower,
         ourAirPower,
@@ -76,14 +76,14 @@ function calculateFirepowerForUnit(unitData: UnitData): number {
         threat +=
             (hpRatio *
                 ((unitData.primaryWeapon.rules.damage + 1) * GameMath.sqrt(unitData.primaryWeapon.rules.range + 1))) /
-            Math.max(unitData.primaryWeapon.cooldownTicks, 1);
+            Math.max(unitData.primaryWeapon.rules.rof, 1);
     }
     if (unitData.secondaryWeapon) {
         threat +=
             (hpRatio *
                 ((unitData.secondaryWeapon.rules.damage + 1) *
                     GameMath.sqrt(unitData.secondaryWeapon.rules.range + 1))) /
-            Math.max(unitData.secondaryWeapon.cooldownTicks, 1);
+            Math.max(unitData.secondaryWeapon.rules.rof, 1);
     }
     return Math.min(800, threat);
 }