@supalosa/chronodivide-bot 0.1.1 → 0.2.0

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

@@ -0,0 +1,152 @@
+import { AttackState, GameApi, ObjectType, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
+import { OneTimeMission } from "./oneTimeMission.js";
+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";
+
+export enum AttackFailReason {
+    NoTargets = 0,
+    DefenceTooStrong = 1,
+}
+
+const NO_TARGET_IDLE_TIMEOUT_TICKS = 60;
+
+/**
+ * A mission that tries to attack a certain area.
+ */
+export class AttackMission extends Mission<AttackFailReason> {
+    private lastTargetSeenAt = 0;
+
+    constructor(
+        uniqueName: string,
+        priority: number,
+        private rallyArea: Point2D,
+        private attackArea: Point2D,
+        private radius: number,
+    ) {
+        super(uniqueName, priority);
+    }
+
+    onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
+        if (this.getSquad() === null) {
+            return this.setSquad(
+                new Squad(this.getUniqueName(), new CombatSquad(this.rallyArea, this.attackArea, this.radius), this),
+            );
+        } 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: UnitData, tryFocusHarvester: boolean) => number = (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 implements MissionFactory {
+    constructor(private lastAttackAt: number = -ATTACK_COOLDOWN_TICKS) {}
+
+    getName(): string {
+        return "AttackMissionFactory";
+    }
+
+    generateTarget(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): Point2D | null {
+        // Randomly decide between harvester and base.
+        try {
+            const tryFocusHarvester = gameApi.generateRandomInt(0, 1) === 0;
+            const enemyUnits = gameApi
+                .getVisibleUnits(playerData.name, "hostile")
+                .map((unitId) => gameApi.getUnitData(unitId))
+                .filter((u) => !!u && gameApi.getPlayerData(u.owner).isCombatant) as UnitData[];
+
+            const maxUnit = _.maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
+            if (maxUnit) {
+                return { 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: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        missionController: MissionController,
+    ): void {
+        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: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        failedMission: Mission,
+        failureReason: any,
+        missionController: MissionController,
+    ): void {}
+}

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

@@ -0,0 +1,104 @@
+import { GameApi, PlayerData, Point2D } from "@chronodivide/game-api";
+import { MatchAwareness } from "../../awareness.js";
+import { MissionController } from "../missionController.js";
+import { Mission, MissionAction, disbandMission, noop } from "../mission.js";
+import { MissionFactory } from "../missionFactories.js";
+import { Squad } from "../../squad/squad.js";
+import { CombatSquad } from "../../squad/behaviours/combatSquad.js";
+import { RetreatMission } from "./retreatMission.js";
+
+export enum DefenceFailReason {
+    NoTargets,
+}
+
+/**
+ * A mission that tries to defend a certain area.
+ */
+export class DefenceMission extends Mission<DefenceFailReason> {
+    private combatSquad?: CombatSquad;
+
+    constructor(
+        uniqueName: string,
+        priority: number,
+        private defenceArea: Point2D,
+        private radius: number,
+    ) {
+        super(uniqueName, priority);
+    }
+
+    onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
+        if (this.getSquad() === null && !this.combatSquad) {
+            this.combatSquad = new CombatSquad(matchAwareness.getMainRallyPoint(), this.defenceArea, this.radius);
+            return this.setSquad(new Squad("defenceSquad-" + this.getUniqueName(), this.combatSquad, this));
+        } else {
+            // Dispatch missions.
+            const foundTargets = matchAwareness.getHostilesNearPoint2d(this.defenceArea, this.radius);
+
+            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 implements MissionFactory {
+    private lastDefenceCheckAt = 0;
+
+    constructor() {}
+
+    getName(): string {
+        return "DefenceMissionFactory";
+    }
+
+    maybeCreateMissions(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        missionController: MissionController,
+    ): void {
+        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: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        failedMission: Mission,
+        failureReason: undefined,
+        missionController: MissionController,
+    ): void {}
+}

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

@@ -0,0 +1,49 @@
+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 { AttackFailReason, AttackMission } from "./attackMission.js";
+import { MissionController } from "../missionController.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: string, priority: number, selectedMcv: number | null) {
+        super(uniqueName, priority, () => new ExpansionSquad(selectedMcv));
+    }
+}
+
+export class ExpansionMissionFactory implements MissionFactory {
+    getName(): string {
+        return "ExpansionMissionFactory";
+    }
+
+    maybeCreateMissions(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        missionController: MissionController,
+    ): 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)
+        );
+        mcvs.forEach((mcv) => {
+            missionController.addMission(new ExpansionMission("expand-with-" + mcv, 100, mcv));
+        });
+    }
+
+    onMissionFailed(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        failedMission: Mission,
+        failureReason: undefined,
+        missionController: MissionController,
+    ): void {
+    }
+}

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

@@ -0,0 +1,32 @@
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { GlobalThreat } from "../../threat/threat.js";
+import { Mission, MissionAction, disbandMission, noop } from "../mission.js";
+import { ExpansionSquad } from "../../squad/behaviours/expansionSquad.js";
+import { Squad } from "../../squad/squad.js";
+import { MissionFactory } from "../missionFactories.js";
+import { SquadBehaviour } from "../../squad/squadBehaviour.js";
+import { MatchAwareness } from "../../awareness.js";
+
+/**
+ * A mission that gets dispatched once, and once the squad decides to disband, the mission is disbanded.
+ */
+export abstract class OneTimeMission<T = undefined> extends Mission<T> {
+    private hadSquad = false;
+
+    constructor(uniqueName: string, priority: number, private behaviourFactory: () => SquadBehaviour) {
+        super(uniqueName, priority);
+    }
+
+    onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
+        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/src/bot/logic/mission/missions/retreatMission.ts

@@ -0,0 +1,9 @@
+import { Point2D } from "@chronodivide/game-api";
+import { OneTimeMission } from "./oneTimeMission.js";
+import { RetreatSquad } from "../../squad/behaviours/retreatSquad.js";
+
+export class RetreatMission extends OneTimeMission {
+    constructor(uniqueName: string, priority: number, retreatToPoint: Point2D, unitIds: number[]) {
+        super(uniqueName, priority, () => new RetreatSquad(unitIds, retreatToPoint));
+    }
+}

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

@@ -0,0 +1,59 @@
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { ScoutingSquad } from "../../squad/behaviours/scoutingSquad.js";
+import { MissionFactory } from "../missionFactories.js";
+import { OneTimeMission } from "./oneTimeMission.js";
+import { MatchAwareness } from "../../awareness.js";
+import { Mission } from "../mission.js";
+import { AttackMission } from "./attackMission.js";
+import { MissionController } from "../missionController.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: string, priority: number) {
+        super(uniqueName, priority, () => new ScoutingSquad());
+    }
+}
+
+const SCOUT_COOLDOWN_TICKS = 300;
+
+export class ScoutingMissionFactory implements MissionFactory {
+    constructor(private lastScoutAt: number = -SCOUT_COOLDOWN_TICKS) {}
+
+    getName(): string {
+        return "ScoutingMissionFactory";
+    }
+
+    maybeCreateMissions(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        missionController: MissionController,
+    ): void {
+        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: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        failedMission: Mission,
+        failureReason: undefined,
+        missionController: MissionController,
+    ): void {
+        if (failedMission instanceof AttackMission) {
+            missionController.addMission(new ScoutingMission("globalScout", 100));
+        }
+    }
+}

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

@@ -0,0 +1,125 @@
+import _ from "lodash";
+import { ActionsApi, GameApi, MovementZone, PlayerData, Point2D } from "@chronodivide/game-api";
+import { Squad } from "../squad.js";
+import { SquadAction, SquadBehaviour, grabCombatants, noop } from "../squadBehaviour.js";
+import { MatchAwareness } from "../../awareness.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 = 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.
+const MIN_GATHER_RADIUS = 5;
+
+// If the radius expands beyond this amount then we should switch back to gathering mode.
+const MAX_GATHER_RADIUS = 15;
+
+const GATHER_RATIO = 10;
+
+enum SquadState {
+    Gathering,
+    Attacking,
+}
+
+export class CombatSquad implements SquadBehaviour {
+    private lastGrab: number | null = null;
+    private lastCommand: number | null = null;
+    private state = SquadState.Gathering;
+
+    /**
+     *
+     * @param rallyArea the initial location to grab combatants
+     * @param targetArea
+     * @param radius
+     */
+    constructor(
+        private rallyArea: Point2D,
+        private targetArea: Point2D,
+        private radius: number,
+    ) {}
+
+    public setAttackArea(targetArea: Point2D) {
+        this.targetArea = targetArea;
+    }
+
+    public onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        squad: Squad,
+        matchAwareness: MatchAwareness,
+    ): SquadAction {
+        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);
+
+            // 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),
+            );
+
+            if (this.state === SquadState.Gathering) {
+                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;
+                const requiredGatherRadius = Math.sqrt(groundUnits.length) * GATHER_RATIO + MAX_GATHER_RADIUS;
+                if (
+                    centerOfMass &&
+                    maxDistance &&
+                    gameApi.mapApi.getTile(centerOfMass.x, centerOfMass.y) !== undefined &&
+                    maxDistance > requiredGatherRadius
+                ) {
+                    // Switch back to gather mode.
+                    this.state = SquadState.Gathering;
+                    return noop();
+                }
+                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(squad.getCenterOfMass() ?? this.rallyArea, GRAB_RADIUS);
+        } else {
+            return noop();
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+import { ActionsApi, ObjectType, OrderType, Point2D, UnitData } from "@chronodivide/game-api";
+import { getDistanceBetweenUnits } from "../../map/map.js";
+
+// Micro methods
+export function manageMoveMicro(actionsApi: ActionsApi, attacker: UnitData, attackPoint: Point2D) {
+    if (attacker.name === "E1") {
+        if (!attacker.canMove) {
+            actionsApi.orderUnits([attacker.id], OrderType.DeploySelected);
+        }
+    }
+    actionsApi.orderUnits([attacker.id], OrderType.Move, attackPoint.x, attackPoint.y);
+}
+
+export function manageAttackMicro(actionsApi: ActionsApi, attacker: UnitData, target: UnitData) {
+    const distance = getDistanceBetweenUnits(attacker, target);
+    if (attacker.name === "E1") {
+        // Para (deployed weapon) range is 5.
+        const deployedWeaponRange = attacker.secondaryWeapon?.maxRange || 5;
+        if (attacker.canMove && distance <= deployedWeaponRange * 0.8) {
+            actionsApi.orderUnits([attacker.id], OrderType.DeploySelected);
+            return;
+        } else if (!attacker.canMove && distance > deployedWeaponRange) {
+            actionsApi.orderUnits([attacker.id], OrderType.DeploySelected);
+            return;
+        }
+    }
+    let targetData = target;
+    let orderType: OrderType = OrderType.Attack;
+    const primaryWeaponRange = attacker.primaryWeapon?.maxRange || 5;
+    if (targetData?.type == ObjectType.Building && distance < primaryWeaponRange * 0.8) {
+        orderType = OrderType.Attack;
+    } else if (targetData?.rules.canDisguise) {
+        // Special case for mirage tank/spy as otherwise they just sit next to it.
+        orderType = OrderType.Attack;
+    }
+    actionsApi.orderUnits([attacker.id], orderType, target.id);
+}

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

@@ -0,0 +1,59 @@
+import { ActionsApi, GameApi, OrderType, PlayerData, SideType } 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";
+import { MatchAwareness } from "../../awareness.js";
+
+const DEPLOY_COOLDOWN_TICKS = 30;
+
+// Expansion or initial base.
+export class ExpansionSquad implements SquadBehaviour {
+    private hasAttemptedDeployWith: {
+        unitId: number;
+        gameTick: number;
+    } | null = null;
+
+    /**
+     * @param selectedMcv ID of the MCV to try to expand with. If that unit dies, the squad will disband. If no value is provided,
+     * the mission requests an MCV.
+     */
+    constructor(private selectedMcv: number | null) {
+    };
+
+    public onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        squad: Squad,
+        matchAwareness: MatchAwareness
+    ): SquadAction {
+        const mcvTypes = ["AMCV", "SMCV"];
+        const mcvs = squad.getUnitsOfTypes(gameApi, ...mcvTypes);
+        if (mcvs.length === 0) {
+            // Perhaps we deployed already (or the unit was destroyed), end the mission.
+            if (this.hasAttemptedDeployWith !== null) {
+                return disband();
+            }
+            // We need an mcv!
+            if (this.selectedMcv) {
+                return requestSpecificUnits([this.selectedMcv], 100);
+            } else {
+                return requestUnits(mcvTypes, 100);
+            }
+        } 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();
+    }
+}

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

@@ -0,0 +1,46 @@
+import { ActionsApi, GameApi, OrderType, PlayerData, Point2D, SideType } 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";
+import { MatchAwareness } from "../../awareness.js";
+
+const SCOUT_MOVE_COOLDOWN_TICKS = 30;
+
+export class RetreatSquad implements SquadBehaviour {
+    private hasRequestedUnits: boolean = false;
+    private moveOrderSentAt: number | null = null;
+    private createdAt: number | null = null;
+
+    constructor(
+        private unitIds: number[],
+        private retreatToPoint: Point2D,
+    ) {}
+
+    public onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        squad: Squad,
+        matchAwareness: MatchAwareness,
+    ): SquadAction {
+        if (!this.createdAt) {
+            this.createdAt = gameApi.getCurrentTick();
+        }
+        if (squad.getUnitIds().length > 0) {
+            // Only send the order once we have managed to claim some units.
+            console.log(`Retreat squad ordered ${squad.getUnitIds()} to retreat`);
+            actionsApi.orderUnits(squad.getUnitIds(), OrderType.Move, this.retreatToPoint.x, this.retreatToPoint.y);
+            if (!this.moveOrderSentAt) {
+                this.moveOrderSentAt = gameApi.getCurrentTick();
+            }
+        }
+        if (
+            (this.moveOrderSentAt && gameApi.getCurrentTick() > this.moveOrderSentAt + 60) ||
+            (this.createdAt && gameApi.getCurrentTick() > this.createdAt + 240)
+        ) {
+            return disband();
+        } else {
+            return requestSpecificUnits(this.unitIds, 100);
+        }
+    }
+}