@supalosa/chronodivide-bot 0.1.1 → 0.2.0

package/dist/bot/logic/common/scout.js

@@ -0,0 +1,10 @@
+export const getUnseenStartingLocations = (gameApi, playerData) => {
+    const unseenStartingLocations = 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;
+    });
+    return unseenStartingLocations;
+};

package/dist/bot/logic/knowledge.js

@@ -0,0 +1 @@
+export {};

package/dist/bot/logic/map/map.js

@@ -55,3 +55,9 @@ export function getPointTowardsOtherPoint(gameApi, startLocation, endLocation, m
 export function getDistanceBetweenPoints(startLocation, endLocation) {
     return Math.sqrt((startLocation.x - endLocation.x) ** 2 + (startLocation.y - endLocation.y) ** 2);
 }
+export function getDistanceBetweenUnits(unit1, unit2) {
+    return getDistanceBetweenPoints({ x: unit1.tile.rx, y: unit1.tile.ry }, { x: unit2.tile.rx, y: unit2.tile.ry });
+}
+export function getDistanceBetween(unit, point) {
+    return getDistanceBetweenPoints({ x: unit.tile.rx, y: unit.tile.ry }, point);
+}

package/dist/bot/logic/map/sector.js

@@ -23,6 +23,9 @@ export class SectorCache {
             }
         }
     }
+    getMapBounds() {
+        return this.mapBounds;
+    }
     updateSectors(currentGameTick, maxSectorsToUpdate, mapApi, playerData) {
         let nextSectorX = this.lastUpdatedSectorX ? this.lastUpdatedSectorX + 1 : 0;
         let nextSectorY = this.lastUpdatedSectorY ? this.lastUpdatedSectorY : 0;
@@ -74,7 +77,9 @@ export class SectorCache {
         }
         return updated / total;
     }
-    // Return % of tiles that are visible. Returns undefined if we haven't scanned the whole map yet.
+    /**
+     * Return the ratio (0-1) of tiles that are visible. Returns undefined if we haven't scanned the whole map yet.
+     */
     getOverallVisibility() {
         let visible = 0, total = 0;
         for (let xx = 0; xx < this.sectorsX; ++xx) {

package/dist/bot/logic/mission/basicMission.js

@@ -1,5 +1,4 @@
-// A basic mission requests specific units and does nothing with them. It is not recommended
-// to actually create this in a game as they'll just sit around idle.
+// A basic mission requests specific units.
 export class BasicMission {
     constructor(uniqueName, priority = 1, squads = []) {
         this.uniqueName = uniqueName;
@@ -23,8 +22,5 @@ export class BasicMission {
     getSquads() {
         return this.squads;
     }
-    onAiUpdate(gameApi, playerData, threatData) {
-        return {};
-    }
     onSquadAdded(gameApi, playerData, threatData) { }
 }

package/dist/bot/logic/mission/expansionMission.js

@@ -1,14 +1,32 @@
-import { BasicMission } from "./basicMission.js";
-export class ExpansionMission extends BasicMission {
+import { Mission, disbandMission, noop } from "./mission.js";
+import { SquadExpansion } from "../squad/behaviours/expansionSquad.js";
+import { Squad } from "../squad/squad.js";
+/**
+ * A mission that tries to create an MCV (if it doesn't exist) and deploy it somewhere it can be deployed.
+ */
+export class ExpansionMission extends Mission {
     constructor(uniqueName, priority) {
         super(uniqueName, priority);
+        this.hadSquad = false;
     }
     onAiUpdate(gameApi, playerData, threatData) {
-        return {};
+        if (this.getSquad() === null) {
+            if (!this.hadSquad) {
+                this.hadSquad = true;
+                return this.setSquad(new Squad(this.getUniqueName(), new SquadExpansion(), this));
+            }
+            else {
+                return disbandMission();
+            }
+        }
+        else {
+            return noop();
+        }
     }
 }
 export class ExpansionMissionFactory {
     maybeCreateMission(gameApi, playerData, threatData, existingMissions) {
-        return new ExpansionMission("expansion", 10);
+        // No auto-expansion missions.
+        return null;
     }
 }

package/dist/bot/logic/mission/mission.js

@@ -1,2 +1,49 @@
-import { ExpansionMissionFactory } from "./expansionMission.js";
-export const missionFactories = [new ExpansionMissionFactory()];
+// AI starts Missions based on heuristics, which have one or more squads.
+// Missions can create squads (but squads will disband themselves).
+export class Mission {
+    constructor(uniqueName, priority = 1) {
+        this.uniqueName = uniqueName;
+        this.priority = priority;
+        this.squad = null;
+        this.active = true;
+        this.onFinish = () => { };
+    }
+    isActive() {
+        return this.active;
+    }
+    setSquad(squad) {
+        this.squad = squad;
+        return registerSquad(squad);
+    }
+    getSquad() {
+        return this.squad;
+    }
+    removeSquad() {
+        // The squad was removed from this mission.
+        this.squad = null;
+    }
+    getUniqueName() {
+        return this.uniqueName;
+    }
+    // Don't call this from the mission itself
+    endMission(reason) {
+        this.onFinish(reason, this.squad);
+        this.squad = null;
+        this.active = false;
+    }
+    /**
+     * Declare a callback that is executed when the mission is disbanded for whatever reason.
+     */
+    then(onFinish) {
+        this.onFinish = onFinish;
+        return this;
+    }
+}
+export const noop = () => ({
+    type: "noop",
+});
+export const registerSquad = (squad) => ({
+    type: "registerSquad",
+    squad,
+});
+export const disbandMission = (reason) => ({ type: "disband", reason });

package/dist/bot/logic/mission/missionController.js

@@ -1,47 +1,80 @@
 // Meta-controller for forming and controlling squads.
-import { missionFactories } from "./mission.js";
+import { createMissionFactories } from "./missionFactories.js";
 export class MissionController {
-    constructor(missions = []) {
-        this.missions = missions;
+    constructor(logger) {
+        this.logger = logger;
+        this.missions = [];
+        this.forceDisbandedMissions = [];
+        this.missionFactories = createMissionFactories();
     }
-    onAiUpdate(gameApi, playerData, threatData) {
-        // Remove disbanded missions.
+    onAiUpdate(gameApi, playerData, matchAwareness, squadController) {
+        // Remove inactive missions.
         this.missions = this.missions.filter((missions) => missions.isActive());
-        let missionActions = this.missions.map((mission) => {
-            return {
-                mission,
-                action: mission.onAiUpdate(gameApi, playerData, threatData),
-            };
-        });
+        // Poll missions for requested actions.
+        const missionActions = this.missions.map((mission) => ({
+            mission,
+            action: mission.onAiUpdate(gameApi, playerData, matchAwareness),
+        }));
         // Handle disbands and merges.
         const isDisband = (a) => a.type == "disband";
-        let disbandedMissions = new Set();
+        const disbandedMissions = new Map();
+        const disbandedMissionsArray = [];
+        this.forceDisbandedMissions.forEach((name) => disbandedMissions.set(name, null));
+        this.forceDisbandedMissions = [];
         missionActions
             .filter((a) => isDisband(a.action))
             .forEach((a) => {
-            a.mission.getSquads().forEach((squad) => {
-                squad.setMission(undefined);
-            });
-            disbandedMissions.add(a.mission.getUniqueName());
+            disbandedMissions.set(a.mission.getUniqueName(), a.action.reason);
+        });
+        // Remove disbanded and merged squads.
+        this.missions
+            .filter((missions) => disbandedMissions.has(missions.getUniqueName()))
+            .forEach((disbandedMission) => {
+            this.logger(`mission disbanded: ${disbandedMission.getUniqueName()}`);
+            const reason = disbandedMissions.get(disbandedMission.getUniqueName());
+            disbandedMissionsArray.push({ mission: disbandedMission, reason });
+            disbandedMission.getSquad()?.setMission(null);
+            disbandedMission.endMission(disbandedMissions.get(disbandedMission.getUniqueName()));
+        });
+        this.missions = this.missions.filter((missions) => !disbandedMissions.has(missions.getUniqueName()));
+        // Register new squads
+        const isNewSquad = (a) => a.type == "registerSquad";
+        missionActions
+            .filter((a) => isNewSquad(a.action))
+            .forEach((a) => {
+            const action = a.action;
+            squadController.registerSquad(action.squad);
+            this.logger(`registered a squad: ${action.squad.getName()}`);
         });
-        // remove disbanded and merged squads.
-        this.missions.filter((missions) => !disbandedMissions.has(missions.getUniqueName()));
-        // Create missions.
-        let newMissions;
-        let missionNames = new Set();
-        this.missions.forEach((mission) => missionNames.add(mission.getUniqueName()));
-        missionFactories.forEach((missionFactory) => {
-            let maybeMission = missionFactory.maybeCreateMission(gameApi, playerData, threatData, this.missions);
-            if (maybeMission) {
-                if (missionNames.has(maybeMission.getUniqueName())) {
-                    //console.log(`Rejecting new mission ${maybeMission.getUniqueName()} as another mission exists.`);
-                }
-                else {
-                    console.log(`Starting new mission ${maybeMission.getUniqueName()}.`);
-                    this.missions.push(maybeMission);
-                    missionNames.add(maybeMission.getUniqueName());
-                }
-            }
+        // Create dynamic missions.
+        this.missionFactories.forEach((missionFactory) => {
+            missionFactory.maybeCreateMissions(gameApi, playerData, matchAwareness, this);
+            disbandedMissionsArray.forEach(({ reason, mission }) => {
+                missionFactory.onMissionFailed(gameApi, playerData, matchAwareness, mission, reason, this);
+            });
         });
     }
+    /**
+     * Attempts to add a mission to the active set.
+     * @param mission
+     * @returns The mission if it was accepted, or null if it was not.
+     */
+    addMission(mission) {
+        if (this.missions.some((m) => m.getUniqueName() === mission.getUniqueName())) {
+            // reject non-unique mission names
+            return null;
+        }
+        this.logger(`Added mission: ${mission.getUniqueName()}`);
+        this.missions.push(mission);
+        return mission;
+    }
+    /**
+     * Disband the provided mission on the next possible opportunity.
+     */
+    disbandMission(missionName) {
+        this.forceDisbandedMissions.push(missionName);
+    }
+    logDebugOutput() {
+        this.logger(`Missions (${this.missions.length}): ${this.missions.map((m) => m.getUniqueName()).join(", ")}`);
+    }
 }

package/dist/bot/logic/mission/missionFactories.js

@@ -0,0 +1,10 @@
+import { ExpansionMissionFactory } from "./missions/expansionMission.js";
+import { ScoutingMissionFactory } from "./missions/scoutingMission.js";
+import { AttackMissionFactory } from "./missions/attackMission.js";
+import { DefenceMissionFactory } from "./missions/defenceMission.js";
+export const createMissionFactories = () => [
+    new ExpansionMissionFactory(),
+    new ScoutingMissionFactory(),
+    new AttackMissionFactory(),
+    new DefenceMissionFactory(),
+];

package/dist/bot/logic/mission/missions/attackMission.js

@@ -0,0 +1,109 @@
+import { ObjectType } from "@chronodivide/game-api";
+import { CombatSquad } from "../../squad/behaviours/combatSquad.js";
+import { Mission, disbandMission, noop } from "../mission.js";
+import { Squad } from "../../squad/squad.js";
+import { RetreatMission } from "./retreatMission.js";
+import _ from "lodash";
+export var AttackFailReason;
+(function (AttackFailReason) {
+    AttackFailReason[AttackFailReason["NoTargets"] = 0] = "NoTargets";
+    AttackFailReason[AttackFailReason["DefenceTooStrong"] = 1] = "DefenceTooStrong";
+})(AttackFailReason || (AttackFailReason = {}));
+const NO_TARGET_IDLE_TIMEOUT_TICKS = 60;
+/**
+ * A mission that tries to attack a certain area.
+ */
+export class AttackMission extends Mission {
+    constructor(uniqueName, priority, rallyArea, attackArea, radius) {
+        super(uniqueName, priority);
+        this.rallyArea = rallyArea;
+        this.attackArea = attackArea;
+        this.radius = radius;
+        this.lastTargetSeenAt = 0;
+    }
+    onAiUpdate(gameApi, playerData, matchAwareness) {
+        if (this.getSquad() === null) {
+            return this.setSquad(new Squad(this.getUniqueName(), new CombatSquad(this.rallyArea, this.attackArea, this.radius), this));
+        }
+        else {
+            // Dispatch missions.
+            if (!matchAwareness.shouldAttack()) {
+                return disbandMission(AttackFailReason.DefenceTooStrong);
+            }
+            const foundTargets = matchAwareness.getHostilesNearPoint2d(this.attackArea, this.radius);
+            if (foundTargets.length > 0) {
+                this.lastTargetSeenAt = gameApi.getCurrentTick();
+            }
+            else if (gameApi.getCurrentTick() > this.lastTargetSeenAt + NO_TARGET_IDLE_TIMEOUT_TICKS) {
+                return disbandMission(AttackFailReason.NoTargets);
+            }
+        }
+        return noop();
+    }
+}
+const ATTACK_COOLDOWN_TICKS = 120;
+// 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.
+const getTargetWeight = (unitData, tryFocusHarvester) => {
+    if (tryFocusHarvester && unitData.rules.harvester) {
+        return 100000;
+    }
+    else if (unitData.type === ObjectType.Building) {
+        return unitData.maxHitPoints * 10;
+    }
+    else {
+        return unitData.maxHitPoints;
+    }
+};
+export class AttackMissionFactory {
+    constructor(lastAttackAt = -ATTACK_COOLDOWN_TICKS) {
+        this.lastAttackAt = lastAttackAt;
+    }
+    getName() {
+        return "AttackMissionFactory";
+    }
+    generateTarget(gameApi, playerData, matchAwareness) {
+        // 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);
+            const maxUnit = _.maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
+            if (maxUnit) {
+                return { x: maxUnit.tile.rx, y: maxUnit.tile.ry };
+            }
+        }
+        catch (err) {
+            // There's a crash here when accessing a building that got destroyed. Will catch and ignore or now.
+            return null;
+        }
+        return null;
+    }
+    maybeCreateMissions(gameApi, playerData, matchAwareness, missionController) {
+        if (!matchAwareness.shouldAttack()) {
+            return;
+        }
+        if (gameApi.getCurrentTick() < this.lastAttackAt + ATTACK_COOLDOWN_TICKS) {
+            return;
+        }
+        const attackRadius = 15;
+        const attackArea = this.generateTarget(gameApi, playerData, matchAwareness);
+        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 tryAttack = missionController
+            .addMission(new AttackMission(squadName, 100, matchAwareness.getMainRallyPoint(), attackArea, attackRadius))
+            ?.then((reason, squad) => {
+            missionController.addMission(new RetreatMission("retreat-from-" + squadName + gameApi.getCurrentTick(), 100, matchAwareness.getMainRallyPoint(), squad?.getUnitIds() ?? []));
+        });
+        if (tryAttack) {
+            this.lastAttackAt = gameApi.getCurrentTick();
+        }
+    }
+    onMissionFailed(gameApi, playerData, matchAwareness, failedMission, failureReason, missionController) { }
+}

package/dist/bot/logic/mission/missions/defenceMission.js

@@ -0,0 +1,62 @@
+import { Mission, disbandMission, noop } from "../mission.js";
+import { Squad } from "../../squad/squad.js";
+import { CombatSquad } from "../../squad/behaviours/combatSquad.js";
+import { RetreatMission } from "./retreatMission.js";
+export var DefenceFailReason;
+(function (DefenceFailReason) {
+    DefenceFailReason[DefenceFailReason["NoTargets"] = 0] = "NoTargets";
+})(DefenceFailReason || (DefenceFailReason = {}));
+/**
+ * A mission that tries to defend a certain area.
+ */
+export class DefenceMission extends Mission {
+    constructor(uniqueName, priority, defenceArea, radius) {
+        super(uniqueName, priority);
+        this.defenceArea = defenceArea;
+        this.radius = radius;
+    }
+    onAiUpdate(gameApi, playerData, matchAwareness) {
+        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);
+            if (foundTargets.length === 0) {
+                return disbandMission(DefenceFailReason.NoTargets);
+            }
+            else {
+                this.combatSquad?.setAttackArea({ x: foundTargets[0].x, y: foundTargets[0].y });
+            }
+        }
+        return noop();
+    }
+}
+const DEFENCE_CHECK_TICKS = 30;
+// Starting radius around the player's base to trigger defense.
+const DEFENCE_STARTING_RADIUS = 20;
+// Every game tick, we increase the defendable area by this amount.
+const DEFENCE_RADIUS_INCREASE_PER_GAME_TICK = 0.005;
+export class DefenceMissionFactory {
+    constructor() {
+        this.lastDefenceCheckAt = 0;
+    }
+    getName() {
+        return "DefenceMissionFactory";
+    }
+    maybeCreateMissions(gameApi, playerData, matchAwareness, missionController) {
+        if (gameApi.getCurrentTick() < this.lastDefenceCheckAt + DEFENCE_CHECK_TICKS) {
+            return;
+        }
+        this.lastDefenceCheckAt = gameApi.getCurrentTick();
+        const defendableRadius = DEFENCE_STARTING_RADIUS + DEFENCE_RADIUS_INCREASE_PER_GAME_TICK * gameApi.getCurrentTick();
+        const enemiesNearSpawn = matchAwareness.getHostilesNearPoint2d(playerData.startLocation, defendableRadius);
+        if (enemiesNearSpawn.length > 0) {
+            missionController.addMission(new DefenceMission("globalDefence", 1000, playerData.startLocation, defendableRadius * 1.2)?.then((reason, squad) => {
+                missionController.addMission(new RetreatMission("retreat-from-globalDefence" + gameApi.getCurrentTick(), 100, matchAwareness.getMainRallyPoint(), squad?.getUnitIds() ?? []));
+            }));
+        }
+    }
+    onMissionFailed(gameApi, playerData, matchAwareness, failedMission, failureReason, missionController) { }
+}

package/dist/bot/logic/mission/missions/expansionMission.js

@@ -0,0 +1,24 @@
+import { ExpansionSquad } from "../../squad/behaviours/expansionSquad.js";
+import { OneTimeMission } from "./oneTimeMission.js";
+/**
+ * A mission that tries to create an MCV (if it doesn't exist) and deploy it somewhere it can be deployed.
+ */
+export class ExpansionMission extends OneTimeMission {
+    constructor(uniqueName, priority, selectedMcv) {
+        super(uniqueName, priority, () => new ExpansionSquad(selectedMcv));
+    }
+}
+export class ExpansionMissionFactory {
+    getName() {
+        return "ExpansionMissionFactory";
+    }
+    maybeCreateMissions(gameApi, playerData, matchAwareness, missionController) {
+        // At this point, only expand if we have a loose MCV.
+        const mcvs = gameApi.getVisibleUnits(playerData.name, "self", (r) => gameApi.getGeneralRules().baseUnit.includes(r.name));
+        mcvs.forEach((mcv) => {
+            missionController.addMission(new ExpansionMission("expand-with-" + mcv, 100, mcv));
+        });
+    }
+    onMissionFailed(gameApi, playerData, matchAwareness, failedMission, failureReason, missionController) {
+    }
+}

package/dist/bot/logic/mission/missions/oneTimeMission.js

@@ -0,0 +1,26 @@
+import { Mission, disbandMission, noop } from "../mission.js";
+import { Squad } from "../../squad/squad.js";
+/**
+ * A mission that gets dispatched once, and once the squad decides to disband, the mission is disbanded.
+ */
+export class OneTimeMission extends Mission {
+    constructor(uniqueName, priority, behaviourFactory) {
+        super(uniqueName, priority);
+        this.behaviourFactory = behaviourFactory;
+        this.hadSquad = false;
+    }
+    onAiUpdate(gameApi, playerData, matchAwareness) {
+        if (this.getSquad() === null) {
+            if (!this.hadSquad) {
+                this.hadSquad = true;
+                return this.setSquad(new Squad(this.getUniqueName(), this.behaviourFactory(), this));
+            }
+            else {
+                return disbandMission();
+            }
+        }
+        else {
+            return noop();
+        }
+    }
+}

package/dist/bot/logic/mission/missions/retreatMission.js

@@ -0,0 +1,7 @@
+import { OneTimeMission } from "./oneTimeMission.js";
+import { RetreatSquad } from "../../squad/behaviours/retreatSquad.js";
+export class RetreatMission extends OneTimeMission {
+    constructor(uniqueName, priority, retreatToPoint, unitIds) {
+        super(uniqueName, priority, () => new RetreatSquad(unitIds, retreatToPoint));
+    }
+}

package/dist/bot/logic/mission/missions/scoutingMission.js

@@ -0,0 +1,38 @@
+import { ScoutingSquad } from "../../squad/behaviours/scoutingSquad.js";
+import { OneTimeMission } from "./oneTimeMission.js";
+import { AttackMission } from "./attackMission.js";
+import { getUnseenStartingLocations } from "../../common/scout.js";
+/**
+ * A mission that tries to scout around the map with a cheap, fast unit (usually attack dogs)
+ */
+export class ScoutingMission extends OneTimeMission {
+    constructor(uniqueName, priority) {
+        super(uniqueName, priority, () => new ScoutingSquad());
+    }
+}
+const SCOUT_COOLDOWN_TICKS = 300;
+export class ScoutingMissionFactory {
+    constructor(lastScoutAt = -SCOUT_COOLDOWN_TICKS) {
+        this.lastScoutAt = lastScoutAt;
+    }
+    getName() {
+        return "ScoutingMissionFactory";
+    }
+    maybeCreateMissions(gameApi, playerData, matchAwareness, missionController) {
+        if (gameApi.getCurrentTick() < this.lastScoutAt + SCOUT_COOLDOWN_TICKS) {
+            return;
+        }
+        const candidatePoints = getUnseenStartingLocations(gameApi, playerData);
+        if (candidatePoints.length === 0) {
+            return;
+        }
+        if (!missionController.addMission(new ScoutingMission("globalScout", 100))) {
+            this.lastScoutAt = gameApi.getCurrentTick();
+        }
+    }
+    onMissionFailed(gameApi, playerData, matchAwareness, failedMission, failureReason, missionController) {
+        if (failedMission instanceof AttackMission) {
+            missionController.addMission(new ScoutingMission("globalScout", 100));
+        }
+    }
+}

package/dist/bot/logic/squad/behaviours/attackSquad.js

@@ -0,0 +1,82 @@
+import _ from "lodash";
+import { MovementZone } from "@chronodivide/game-api";
+import { grabCombatants, noop } from "../squadBehaviour.js";
+import { getDistanceBetweenPoints } from "../../map/map.js";
+import { manageAttackMicro, manageMoveMicro } from "./common.js";
+const TARGET_UPDATE_INTERVAL_TICKS = 10;
+const GRAB_INTERVAL_TICKS = 10;
+const GRAB_RADIUS = 30;
+// Units must be in a certain radius of the center of mass before attacking.
+// This scales for number of units in the squad though.
+const MIN_GATHER_RADIUS = 5;
+const GATHER_RATIO = 10;
+var SquadState;
+(function (SquadState) {
+    SquadState[SquadState["Gathering"] = 0] = "Gathering";
+    SquadState[SquadState["Attacking"] = 1] = "Attacking";
+})(SquadState || (SquadState = {}));
+export class AttackOrDefenceSquad {
+    constructor(rallyArea, targetArea, radius) {
+        this.rallyArea = rallyArea;
+        this.targetArea = targetArea;
+        this.radius = radius;
+        this.lastGrab = null;
+        this.lastCommand = null;
+        this.state = SquadState.Gathering;
+    }
+    setAttackArea(targetArea) {
+        this.targetArea = targetArea;
+    }
+    onAiUpdate(gameApi, actionsApi, playerData, squad, matchAwareness) {
+        if (!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);
+            if (this.state === SquadState.Gathering) {
+                // Only use ground units for center of mass.
+                const groundUnits = squad.getUnitsMatching(gameApi, (r) => r.rules.isSelectableCombatant &&
+                    (r.rules.movementZone === MovementZone.Infantry ||
+                        r.rules.movementZone === MovementZone.Normal ||
+                        r.rules.movementZone === MovementZone.InfantryDestroyer));
+                const requiredGatherRadius = Math.sqrt(groundUnits.length) * GATHER_RATIO + MIN_GATHER_RADIUS;
+                if (centerOfMass &&
+                    maxDistance &&
+                    gameApi.mapApi.getTile(centerOfMass.x, centerOfMass.y) !== undefined &&
+                    maxDistance > requiredGatherRadius) {
+                    units.forEach((unit) => {
+                        manageMoveMicro(actionsApi, unit, centerOfMass);
+                    });
+                }
+                else {
+                    this.state = SquadState.Attacking;
+                }
+            }
+            else {
+                const targetPoint = this.targetArea || playerData.startLocation;
+                for (const unit of units) {
+                    if (unit.isIdle) {
+                        const { rx: x, ry: y } = unit.tile;
+                        const range = unit.primaryWeapon?.maxRange ?? unit.secondaryWeapon?.maxRange ?? 5;
+                        const nearbyHostiles = matchAwareness.getHostilesNearPoint(x, y, range * 2);
+                        const closest = _.minBy(nearbyHostiles, ({ x: hX, y: hY }) => getDistanceBetweenPoints({ x, y }, { x: hX, y: hY }));
+                        const closestUnit = closest ? gameApi.getUnitData(closest.unitId) ?? null : null;
+                        if (closestUnit) {
+                            manageAttackMicro(actionsApi, unit, closestUnit);
+                        }
+                        else {
+                            manageMoveMicro(actionsApi, unit, targetPoint);
+                        }
+                    }
+                }
+            }
+        }
+        if (!this.lastGrab || gameApi.getCurrentTick() > this.lastGrab + GRAB_INTERVAL_TICKS) {
+            this.lastGrab = gameApi.getCurrentTick();
+            return grabCombatants(this.rallyArea, this.radius * GRAB_RADIUS);
+        }
+        else {
+            return noop();
+        }
+    }
+}