@supalosa/chronodivide-bot 0.2.0 → 0.2.2-a

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

@@ -1,16 +1,13 @@
-import { AttackState, GameApi, ObjectType, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
-import { OneTimeMission } from "./oneTimeMission.js";
+import { GameApi, ObjectType, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
 import { CombatSquad } from "../../squad/behaviours/combatSquad.js";
 import { Mission, MissionAction, disbandMission, noop } from "../mission.js";
-import { GlobalThreat } from "../../threat/threat.js";
 import { Squad } from "../../squad/squad.js";
-import { getDistanceBetweenPoints, getDistanceBetweenUnits } from "../../map/map.js";
 import { MissionFactory } from "../missionFactories.js";
 import { MatchAwareness } from "../../awareness.js";
 import { MissionController } from "../missionController.js";
-import { match } from "assert";
 import { RetreatMission } from "./retreatMission.js";
-import _ from "lodash";
+import maxBy from "lodash.maxby";
+import { DebugLogger } from "../../common/utils.js";
 
 export enum AttackFailReason {
     NoTargets = 0,
@@ -31,8 +28,9 @@ export class AttackMission extends Mission<AttackFailReason> {
         private rallyArea: Point2D,
         private attackArea: Point2D,
         private radius: number,
+        logger: DebugLogger,
     ) {
-        super(uniqueName, priority);
+        super(uniqueName, priority, logger);
     }
 
     onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
@@ -88,7 +86,7 @@ export class AttackMissionFactory implements MissionFactory {
                 .map((unitId) => gameApi.getUnitData(unitId))
                 .filter((u) => !!u && gameApi.getPlayerData(u.owner).isCombatant) as UnitData[];
 
-            const maxUnit = _.maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
+            const maxUnit = maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
             if (maxUnit) {
                 return { x: maxUnit.tile.rx, y: maxUnit.tile.ry };
             }
@@ -104,6 +102,7 @@ export class AttackMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
+        logger: DebugLogger,
     ): void {
         if (!matchAwareness.shouldAttack()) {
             return;
@@ -124,18 +123,26 @@ export class AttackMissionFactory implements MissionFactory {
         // 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) => {
+        const tryAttack = missionController.addMission(
+            new AttackMission(
+                squadName,
+                100,
+                matchAwareness.getMainRallyPoint(),
+                attackArea,
+                attackRadius,
+                logger,
+            ).then((reason, squad) => {
                 missionController.addMission(
                     new RetreatMission(
                         "retreat-from-" + squadName + gameApi.getCurrentTick(),
                         100,
                         matchAwareness.getMainRallyPoint(),
                         squad?.getUnitIds() ?? [],
+                        logger,
                     ),
                 );
-            });
+            }),
+        );
         if (tryAttack) {
             this.lastAttackAt = gameApi.getCurrentTick();
         }

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

@@ -6,6 +6,7 @@ import { MissionFactory } from "../missionFactories.js";
 import { Squad } from "../../squad/squad.js";
 import { CombatSquad } from "../../squad/behaviours/combatSquad.js";
 import { RetreatMission } from "./retreatMission.js";
+import { DebugLogger } from "../../common/utils.js";
 
 export enum DefenceFailReason {
     NoTargets,
@@ -22,8 +23,9 @@ export class DefenceMission extends Mission<DefenceFailReason> {
         priority: number,
         private defenceArea: Point2D,
         private radius: number,
+        logger: DebugLogger,
     ) {
-        super(uniqueName, priority);
+        super(uniqueName, priority, logger);
     }
 
     onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
@@ -35,8 +37,15 @@ export class DefenceMission extends Mission<DefenceFailReason> {
             const foundTargets = matchAwareness.getHostilesNearPoint2d(this.defenceArea, this.radius);
 
             if (foundTargets.length === 0) {
+                this.logger(`(Defence Mission ${this.getUniqueName()}): No targets found, disbanding.`);
                 return disbandMission(DefenceFailReason.NoTargets);
             } else {
+                const targetUnit = gameApi.getUnitData(foundTargets[0].unitId);
+                this.logger(
+                    `(Defence Mission ${this.getUniqueName()}): Focused on target ${targetUnit?.name} (${
+                        foundTargets.length
+                    } found in area ${this.radius})`,
+                );
                 this.combatSquad?.setAttackArea({ x: foundTargets[0].x, y: foundTargets[0].y });
             }
         }
@@ -47,9 +56,9 @@ export class DefenceMission extends Mission<DefenceFailReason> {
 const DEFENCE_CHECK_TICKS = 30;
 
 // Starting radius around the player's base to trigger defense.
-const DEFENCE_STARTING_RADIUS = 20;
+const DEFENCE_STARTING_RADIUS = 10;
 // Every game tick, we increase the defendable area by this amount.
-const DEFENCE_RADIUS_INCREASE_PER_GAME_TICK = 0.005;
+const DEFENCE_RADIUS_INCREASE_PER_GAME_TICK = 0.001;
 
 export class DefenceMissionFactory implements MissionFactory {
     private lastDefenceCheckAt = 0;
@@ -65,6 +74,7 @@ export class DefenceMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
+        logger: DebugLogger,
     ): void {
         if (gameApi.getCurrentTick() < this.lastDefenceCheckAt + DEFENCE_CHECK_TICKS) {
             return;
@@ -76,19 +86,29 @@ export class DefenceMissionFactory implements MissionFactory {
         const enemiesNearSpawn = matchAwareness.getHostilesNearPoint2d(playerData.startLocation, defendableRadius);
 
         if (enemiesNearSpawn.length > 0) {
+            logger(
+                `Starting defence mission, ${
+                    enemiesNearSpawn.length
+                } found in radius ${defendableRadius} (tick ${gameApi.getCurrentTick()})`,
+            );
             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() ?? [],
-                            ),
-                        );
-                    },
-                ),
+                new DefenceMission(
+                    "globalDefence",
+                    1000,
+                    playerData.startLocation,
+                    defendableRadius * 1.2,
+                    logger,
+                ).then((reason, squad) => {
+                    missionController.addMission(
+                        new RetreatMission(
+                            "retreat-from-globalDefence" + gameApi.getCurrentTick(),
+                            100,
+                            matchAwareness.getMainRallyPoint(),
+                            squad?.getUnitIds() ?? [],
+                            logger,
+                        ),
+                    );
+                }),
             );
         }
     }

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

@@ -0,0 +1,61 @@
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { GlobalThreat } from "../../threat/threat.js";
+import { Mission } from "../mission.js";
+import { ExpansionSquad } from "../../squad/behaviours/expansionSquad.js";
+import { MissionFactory } from "../missionFactories.js";
+import { OneTimeMission } from "./oneTimeMission.js";
+import { MatchAwareness } from "../../awareness.js";
+import { MissionController } from "../missionController.js";
+import { DebugLogger } from "../../common/utils.js";
+import { EngineerSquad } from "../../squad/behaviours/engineerSquad.js";
+
+/**
+ * A mission that tries to send an engineer into a building (e.g. to capture tech building or repair bridge)
+ */
+export class EngineerMission extends OneTimeMission {
+    constructor(uniqueName: string, priority: number, selectedTechBuilding: number, 
+        logger: DebugLogger) {
+        super(uniqueName, priority, () => new EngineerSquad(selectedTechBuilding), logger);
+    }
+}
+
+// Only try to capture tech buildings within this radius of the starting point.
+const MAX_TECH_CAPTURE_RADIUS = 50;
+
+const TECH_CHECK_INTERVAL_TICKS = 300;
+
+export class EngineerMissionFactory implements MissionFactory {
+    private lastCheckAt = 0;
+
+    getName(): string {
+        return "EngineerMissionFactory";
+    }
+
+    maybeCreateMissions(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        missionController: MissionController,
+        logger: DebugLogger
+    ): void {
+        if (!(gameApi.getCurrentTick() > this.lastCheckAt + TECH_CHECK_INTERVAL_TICKS)) {
+            return;
+        }
+        this.lastCheckAt = gameApi.getCurrentTick();
+        const eligibleTechBuildings = gameApi.getVisibleUnits(playerData.name, "hostile", (r) => r.capturable && r.produceCashAmount > 0);
+
+        eligibleTechBuildings.forEach((techBuildingId) => {
+            missionController.addMission(new EngineerMission("capture-" + techBuildingId, 100, techBuildingId, logger));
+        });
+    }
+
+    onMissionFailed(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        failedMission: Mission,
+        failureReason: undefined,
+        missionController: MissionController,
+    ): void {
+    }
+}

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

@@ -5,15 +5,16 @@ 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";
+import { DebugLogger } from "../../common/utils.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));
+    constructor(uniqueName: string, priority: number, selectedMcv: number | null, 
+        logger: DebugLogger) {
+        super(uniqueName, priority, () => new ExpansionSquad(selectedMcv), logger);
     }
 }
 
@@ -27,13 +28,14 @@ export class ExpansionMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
+        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)
         );
         mcvs.forEach((mcv) => {
-            missionController.addMission(new ExpansionMission("expand-with-" + mcv, 100, mcv));
+            missionController.addMission(new ExpansionMission("expand-with-" + mcv, 100, mcv, logger));
         });
     }
 

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

@@ -6,6 +6,7 @@ import { Squad } from "../../squad/squad.js";
 import { MissionFactory } from "../missionFactories.js";
 import { SquadBehaviour } from "../../squad/squadBehaviour.js";
 import { MatchAwareness } from "../../awareness.js";
+import { DebugLogger } from "../../common/utils.js";
 
 /**
  * A mission that gets dispatched once, and once the squad decides to disband, the mission is disbanded.
@@ -13,8 +14,8 @@ import { MatchAwareness } from "../../awareness.js";
 export abstract class OneTimeMission<T = undefined> extends Mission<T> {
     private hadSquad = false;
 
-    constructor(uniqueName: string, priority: number, private behaviourFactory: () => SquadBehaviour) {
-        super(uniqueName, priority);
+    constructor(uniqueName: string, priority: number, private behaviourFactory: () => SquadBehaviour, logger: DebugLogger) {
+        super(uniqueName, priority, logger);
     }
 
     onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {

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

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

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

@@ -7,13 +7,15 @@ import { Mission } 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";
 
 /**
  * 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());
+    constructor(uniqueName: string, priority: number, 
+        logger: DebugLogger) {
+        super(uniqueName, priority, () => new ScoutingSquad(), logger);
     }
 }
 
@@ -31,15 +33,15 @@ export class ScoutingMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
+        logger: DebugLogger
     ): void {
         if (gameApi.getCurrentTick() < this.lastScoutAt + SCOUT_COOLDOWN_TICKS) {
             return;
         }
-        const candidatePoints = getUnseenStartingLocations(gameApi, playerData);
-        if (candidatePoints.length === 0) {
+        if (!matchAwareness.getScoutingManager().hasScoutTargets()) {
             return;
         }
-        if (!missionController.addMission(new ScoutingMission("globalScout", 100))) {
+        if (!missionController.addMission(new ScoutingMission("globalScout", 100, logger))) {
             this.lastScoutAt = gameApi.getCurrentTick();
         }
     }
@@ -51,9 +53,10 @@ export class ScoutingMissionFactory implements MissionFactory {
         failedMission: Mission,
         failureReason: undefined,
         missionController: MissionController,
+        logger: DebugLogger
     ): void {
         if (failedMission instanceof AttackMission) {
-            missionController.addMission(new ScoutingMission("globalScout", 100));
+            missionController.addMission(new ScoutingMission("globalScout", 100, logger));
         }
     }
 }

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

@@ -1,10 +1,11 @@
-import _ from "lodash";
-import { ActionsApi, GameApi, MovementZone, PlayerData, Point2D } from "@chronodivide/game-api";
+import maxBy from "lodash.maxby";
+import { ActionsApi, GameApi, MovementZone, PlayerData, Point2D, UnitData } 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";
+import { getAttackWeight, manageAttackMicro, manageMoveMicro } from "./common.js";
+import { DebugLogger } from "../../common/utils.js";
 
 const TARGET_UPDATE_INTERVAL_TICKS = 10;
 const GRAB_INTERVAL_TICKS = 10;
@@ -52,8 +53,12 @@ export class CombatSquad implements SquadBehaviour {
         playerData: PlayerData,
         squad: Squad,
         matchAwareness: MatchAwareness,
+        logger: DebugLogger,
     ): SquadAction {
-        if (!this.lastCommand || gameApi.getCurrentTick() > this.lastCommand + TARGET_UPDATE_INTERVAL_TICKS) {
+        if (
+            squad.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();
@@ -81,6 +86,7 @@ export class CombatSquad implements SquadBehaviour {
                         manageMoveMicro(actionsApi, unit, centerOfMass);
                     });
                 } else {
+                    logger(`CombatSquad ${squad.getName()} switching back to attack mode (${maxDistance})`);
                     this.state = SquadState.Attacking;
                 }
             } else {
@@ -92,24 +98,22 @@ export class CombatSquad implements SquadBehaviour {
                     gameApi.mapApi.getTile(centerOfMass.x, centerOfMass.y) !== undefined &&
                     maxDistance > requiredGatherRadius
                 ) {
-                    // Switch back to gather mode.
+                    // Switch back to gather mode
+                    logger(`CombatSquad ${squad.getName()} switching back to gather (${maxDistance})`);
                     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);
-                        }
+                    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) {
+                        manageAttackMicro(actionsApi, unit, bestUnit);
+                    } else {
+                        manageMoveMicro(actionsApi, unit, targetPoint);
                     }
                 }
             }

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

@@ -1,10 +1,21 @@
-import { ActionsApi, ObjectType, OrderType, Point2D, UnitData } from "@chronodivide/game-api";
-import { getDistanceBetweenUnits } from "../../map/map.js";
+import {
+    ActionsApi,
+    AttackState,
+    ObjectType,
+    OrderType,
+    Point2D,
+    StanceType,
+    UnitData,
+    ZoneType,
+} from "@chronodivide/game-api";
+import { getDistanceBetweenPoints, getDistanceBetweenUnits } from "../../map/map.js";
+import { Zone } from "luxon";
 
 // Micro methods
 export function manageMoveMicro(actionsApi: ActionsApi, attacker: UnitData, attackPoint: Point2D) {
     if (attacker.name === "E1") {
-        if (!attacker.canMove) {
+        const isDeployed = attacker.stance === StanceType.Deployed;
+        if (isDeployed) {
             actionsApi.orderUnits([attacker.id], OrderType.DeploySelected);
         }
     }
@@ -16,10 +27,11 @@ export function manageAttackMicro(actionsApi: ActionsApi, attacker: UnitData, ta
     if (attacker.name === "E1") {
         // Para (deployed weapon) range is 5.
         const deployedWeaponRange = attacker.secondaryWeapon?.maxRange || 5;
-        if (attacker.canMove && distance <= deployedWeaponRange * 0.8) {
+        const isDeployed = attacker.stance === StanceType.Deployed;
+        if (!isDeployed && (distance <= deployedWeaponRange || attacker.attackState === AttackState.JustFired)) {
             actionsApi.orderUnits([attacker.id], OrderType.DeploySelected);
             return;
-        } else if (!attacker.canMove && distance > deployedWeaponRange) {
+        } else if (isDeployed && distance > deployedWeaponRange) {
             actionsApi.orderUnits([attacker.id], OrderType.DeploySelected);
             return;
         }
@@ -35,3 +47,24 @@ export function manageAttackMicro(actionsApi: ActionsApi, attacker: UnitData, ta
     }
     actionsApi.orderUnits([attacker.id], orderType, target.id);
 }
+
+/**
+ *
+ * @param attacker
+ * @param target
+ * @returns A number describing the weight of the given target for the attacker, or null if it should not attack it.
+ */
+export function getAttackWeight(attacker: UnitData, target: UnitData): number | null {
+    const { rx: x, ry: y } = attacker.tile;
+    const { rx: hX, ry: hY } = target.tile;
+
+    if (!attacker.primaryWeapon?.projectileRules.isAntiAir && target.zone === ZoneType.Air) {
+        return null;
+    }
+
+    if (!attacker.primaryWeapon?.projectileRules.isAntiGround && target.zone === ZoneType.Ground) {
+        return null;
+    }
+
+    return 1000000 - getDistanceBetweenPoints({ x, y }, { x: hX, y: hY });
+}

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

@@ -0,0 +1,53 @@
+import { ActionsApi, GameApi, OrderType, PlayerData, SideType } from "@chronodivide/game-api";
+import { Squad } from "../squad.js";
+import { SquadAction, SquadBehaviour, disband, noop, requestSpecificUnits, requestUnits } from "../squadBehaviour.js";
+import { MatchAwareness } from "../../awareness.js";
+
+const CAPTURE_COOLDOWN_TICKS = 30;
+
+// Capture squad
+export class EngineerSquad implements SquadBehaviour {
+    private hasAttemptedCaptureWith: {
+        unitId: number;
+        gameTick: number;
+    } | null = null;
+
+    /**
+     * @param captureTarget ID of the target to try and capture/send engineer into.
+     */
+    constructor(private captureTarget: number) {
+    };
+
+    public onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        squad: Squad,
+        matchAwareness: MatchAwareness
+    ): SquadAction {
+        const engineerTypes = ["ENGINEER", "SENGINEER"];
+        const engineers = squad.getUnitsOfTypes(gameApi, ...engineerTypes);
+        if (engineers.length === 0) {
+            // Perhaps we deployed already (or the unit was destroyed), end the mission.
+            if (this.hasAttemptedCaptureWith !== null) {
+                return disband();
+            }
+            return requestUnits(engineerTypes, 100);
+        } else if (
+            !this.hasAttemptedCaptureWith ||
+            gameApi.getCurrentTick() > this.hasAttemptedCaptureWith.gameTick + CAPTURE_COOLDOWN_TICKS
+        ) {
+            actionsApi.orderUnits(
+                engineers.map((engineer) => engineer.id),
+                OrderType.Capture,
+                this.captureTarget
+            );
+            // Add a cooldown to deploy attempts.
+            this.hasAttemptedCaptureWith = {
+                unitId: engineers[0].id,
+                gameTick: gameApi.getCurrentTick(),
+            };
+        }
+        return noop();
+    }
+}

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

@@ -7,8 +7,6 @@ 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(
@@ -28,19 +26,19 @@ export class RetreatSquad implements SquadBehaviour {
         }
         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();
-            }
+            actionsApi.orderUnits(
+                squad.getUnitIds(),
+                OrderType.AttackMove,
+                this.retreatToPoint.x,
+                this.retreatToPoint.y,
+            );
+            return disband();
         }
-        if (
-            (this.moveOrderSentAt && gameApi.getCurrentTick() > this.moveOrderSentAt + 60) ||
-            (this.createdAt && gameApi.getCurrentTick() > this.createdAt + 240)
-        ) {
+        if (this.createdAt && gameApi.getCurrentTick() > this.createdAt + 240) {
+            // Disband automatically after 240 ticks in case we couldn't actually claim any units.
             return disband();
         } else {
-            return requestSpecificUnits(this.unitIds, 100);
+            return requestSpecificUnits(this.unitIds, 1000);
         }
     }
 }