@supalosa/chronodivide-bot 0.2.1 → 0.2.2

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 });
             }
         }
@@ -49,7 +58,7 @@ const DEFENCE_CHECK_TICKS = 30;
 // Starting radius around the player's base to trigger defense.
 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/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

@@ -5,6 +5,7 @@ import { SquadAction, SquadBehaviour, grabCombatants, noop } from "../squadBehav
 import { MatchAwareness } from "../../awareness.js";
 import { getDistanceBetweenPoints } from "../../map/map.js";
 import { 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,9 @@ 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 +83,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 {
@@ -93,6 +96,7 @@ export class CombatSquad implements SquadBehaviour {
                     maxDistance > requiredGatherRadius
                 ) {
                     // Switch back to gather mode
+                    logger(`CombatSquad ${squad.getName()} switching back to gather (${maxDistance})`)
                     this.state = SquadState.Gathering;
                     return noop();
                 }

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

@@ -4,14 +4,30 @@ import { Squad } from "../squad.js";
 import { SquadAction, SquadBehaviour, disband, noop, requestUnits } from "../squadBehaviour.js";
 import { MatchAwareness } from "../../awareness.js";
 import { getUnseenStartingLocations } from "../../common/scout.js";
+import { match } from "assert";
+import { DebugLogger } from "../../common/utils.js";
+import _ from "lodash";
+import { getDistanceBetweenPoints, getDistanceBetweenUnits } from "../../map/map.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;
+
 export class ScoutingSquad implements SquadBehaviour {
-    private scoutingWith: {
-        unitId: number;
-        gameTick: number;
-    } | null = null;
+    private scoutTarget: Point2D | null = null;
+    private attemptsOnCurrentTarget: number = 0;
+    private scoutTargetRefreshedAt: number = 0;
+    private lastMoveCommandTick: number = 0;
+
+    // Minimum distance from a scout to the target.
+    private scoutMinDistance?: number;
+
+    private hadUnit: boolean = false;
 
     public onAiUpdate(
         gameApi: GameApi,
@@ -19,6 +35,7 @@ export class ScoutingSquad implements SquadBehaviour {
         playerData: PlayerData,
         squad: Squad,
         matchAwareness: MatchAwareness,
+        logger: DebugLogger,
     ): SquadAction {
         const scoutNames = ["ADOG", "DOG", "E1", "E2", "FV", "HTK"];
         const scouts = squad.getUnitsOfTypes(gameApi, ...scoutNames);
@@ -28,29 +45,70 @@ export class ScoutingSquad implements SquadBehaviour {
         }
 
         if (scouts.length === 0) {
-            this.scoutingWith = null;
+            // 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, 100);
-        } else if (
-            !this.scoutingWith ||
-            gameApi.getCurrentTick() > this.scoutingWith.gameTick + SCOUT_MOVE_COOLDOWN_TICKS
-        ) {
-            const candidatePoints = getUnseenStartingLocations(gameApi, playerData);
-            scouts.forEach((unit) => {
-                if (candidatePoints.length > 0) {
-                    if (unit?.isIdle) {
-                        const scoutLocation =
-                            candidatePoints[Math.floor(gameApi.generateRandom() * candidatePoints.length)];
-                        actionsApi.orderUnits([unit.id], OrderType.AttackMove, scoutLocation.x, scoutLocation.y);
+        } else if (this.scoutTarget) {
+            this.hadUnit = true;
+            if (this.attemptsOnCurrentTarget > MAX_ATTEMPTS_PER_TARGET) {
+                logger(
+                    `Scout target ${this.scoutTarget.x},${this.scoutTarget.y} took too many attempts, moving to next`,
+                );
+                this.setScoutTarget(null, 0);
+                return noop();
+            }
+            if (gameApi.getCurrentTick() > this.scoutTargetRefreshedAt + MAX_TICKS_PER_TARGET) {
+                logger(`Scout target ${this.scoutTarget.x},${this.scoutTarget.y} took too long, moving to next`);
+                this.setScoutTarget(null, 0);
+                return noop();
+            }
+            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 newMinDistance = _.min(
+                    scouts.map((unit) =>
+                        getDistanceBetweenPoints({ x: unit.tile.rx, y: unit.tile.ry }, this.scoutTarget!),
+                    ),
+                )!;
+                if (!this.scoutMinDistance || newMinDistance < this.scoutMinDistance) {
+                    logger(
+                        `Scout timeout refreshed because unit moved closer to point (${newMinDistance} < ${this.scoutMinDistance})`,
+                    );
+                    this.scoutTargetRefreshedAt = gameApi.getCurrentTick();
+                    this.scoutMinDistance = newMinDistance;
                 }
-            });
-
-            // Add a cooldown to scout attempts.
-            this.scoutingWith = {
-                unitId: scouts[0].id,
-                gameTick: gameApi.getCurrentTick(),
-            };
+            }
+            if (gameApi.mapApi.isVisibleTile(targetTile, playerData.name)) {
+                logger(`Scout target ${this.scoutTarget.x},${this.scoutTarget.y} successfully scouted, moving to next`);
+                this.setScoutTarget(null, gameApi.getCurrentTick());
+            }
+        } else {
+            const candidatePoint = matchAwareness.getScoutingManager().getNewScoutTarget()?.asPoint2D();
+            if (!candidatePoint) {
+                logger(`No more scouting targets available, disbanding.`);
+                return disband();
+            }
+            this.setScoutTarget(candidatePoint, gameApi.getCurrentTick());
         }
         return noop();
     }
+
+    setScoutTarget(point: Point2D | null, currentTick: number) {
+        this.attemptsOnCurrentTarget = 0;
+        this.scoutTargetRefreshedAt = currentTick;
+        this.scoutTarget = point;
+        this.scoutMinDistance = undefined;
+    }
 }

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

@@ -5,6 +5,7 @@ import { SquadAction, SquadBehaviour, disband } from "./squadBehaviour.js";
 import { MatchAwareness } from "../awareness.js";
 import { getDistanceBetweenPoints } from "../map/map.js";
 import _ from "lodash";
+import { DebugLogger } from "../common/utils.js";
 
 export enum SquadLiveness {
     SquadDead,
@@ -76,6 +77,7 @@ export class Squad {
         actionsApi: ActionsApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
+        logger: DebugLogger
     ): SquadAction {
         this.updateLiveness(gameApi);
         const movableUnitTiles = this.unitIds
@@ -100,8 +102,7 @@ export class Squad {
         } else if (!this.mission) {
             return disband();
         }
-        let outcome = this.behaviour.onAiUpdate(gameApi, actionsApi, playerData, this, matchAwareness);
-        return outcome;
+        return this.behaviour.onAiUpdate(gameApi, actionsApi, playerData, this, matchAwareness, logger);
     }
     public getMission(): Mission | null {
         return this.mission;

package/src/bot/logic/squad/squadBehaviour.ts

@@ -2,6 +2,7 @@ import { ActionsApi, GameApi, PlayerData, Point2D } from "@chronodivide/game-api
 import { GlobalThreat } from "../threat/threat.js";
 import { Squad } from "./squad.js";
 import { MatchAwareness } from "../awareness.js";
+import { DebugLogger } from "../common/utils.js";
 
 export type SquadActionNoop = {
     type: "noop";
@@ -56,6 +57,7 @@ export interface SquadBehaviour {
         actionsApi: ActionsApi,
         playerData: PlayerData,
         squad: Squad,
-        matchAwareness: MatchAwareness
+        matchAwareness: MatchAwareness,
+        logger: DebugLogger
     ): SquadAction;
 }

package/src/bot/logic/squad/squadController.ts

@@ -14,6 +14,7 @@ import {
 import { MatchAwareness } from "../awareness.js";
 import { getDistanceBetween } from "../map/map.js";
 import _ from "lodash";
+import { DebugLogger } from "../common/utils.js";
 
 type SquadWithAction<T> = {
     squad: Squad;
@@ -51,7 +52,7 @@ export class SquadController {
         const squadActions: SquadWithAction<SquadAction>[] = this.squads.map((squad) => {
             return {
                 squad,
-                action: squad.onAiUpdate(gameApi, actionsApi, playerData, matchAwareness),
+                action: squad.onAiUpdate(gameApi, actionsApi, playerData, matchAwareness, this.logger),
             };
         });
         // Handle disbands and merges.
@@ -105,21 +106,43 @@ export class SquadController {
                 },
                 {} as Record<number, SquadWithAction<SquadActionRequestSpecificUnits>>,
             );
-        Object.entries(unitIdToHighestRequest).forEach(([id, request]) => {
-            const unitId = Number.parseInt(id);
-            const unit = gameApi.getUnitData(unitId);
-            const { squad: requestingSquad } = request;
-            const missionName = requestingSquad.getMission()?.getUniqueName();
-            if (!unit) {
-                this.logger(`mission ${missionName} requested non-existent unit ${unitId}`);
-                return;
-            }
-            if (!this.unitIdToSquad.has(unitId)) {
-                this.logger(
-                    `granting specific unit ${unitId} to squad ${requestingSquad.getName()} in mission ${missionName}`,
-                );
-                this.addUnitToSquad(requestingSquad, unit);
-            }
+
+        // Map of Squad ID to Unit Type to Count.
+        const newSquadAssignments = Object.entries(unitIdToHighestRequest)
+            .flatMap(([id, request]) => {
+                const unitId = Number.parseInt(id);
+                const unit = gameApi.getUnitData(unitId);
+                const { squad: requestingSquad } = request;
+                const missionName = requestingSquad.getMission()?.getUniqueName();
+                if (!unit) {
+                    this.logger(`mission ${missionName} requested non-existent unit ${unitId}`);
+                    return [];
+                }
+                if (!this.unitIdToSquad.has(unitId)) {
+                    this.addUnitToSquad(requestingSquad, unit);
+                    return [{ unitName: unit?.name, squad: requestingSquad.getName() }];
+                }
+                return [];
+            })
+            .reduce(
+                (acc, curr) => {
+                    if (!acc[curr.squad]) {
+                        acc[curr.squad] = {};
+                    }
+                    if (!acc[curr.squad][curr.unitName]) {
+                        acc[curr.squad][curr.unitName] = 0;
+                    }
+                    acc[curr.squad][curr.unitName] = acc[curr.squad][curr.unitName] + 1;
+                    return acc;
+                },
+                {} as Record<string, Record<string, number>>,
+            );
+        Object.entries(newSquadAssignments).forEach(([squad, assignments]) => {
+            this.logger(
+                `Squad ${squad} received: ${Object.entries(assignments)
+                    .map(([unitType, count]) => unitType + " x " + count)
+                    .join(", ")}`,
+            );
         });
 
         // Request units by type
@@ -157,33 +180,57 @@ export class SquadController {
             .filter((unit) => !!unit && !this.unitIdToSquad.has(unit.id || 0))
             .map((unit) => unit!);
 
-        freeUnits.forEach((freeUnit) => {
-            if (unitTypeToHighestRequest.hasOwnProperty(freeUnit.name)) {
-                const { squad: requestingSquad } = unitTypeToHighestRequest[freeUnit.name];
-                this.logger(`granting unit ${freeUnit.id}#${freeUnit.name} to squad ${requestingSquad.getName()}`);
-                this.addUnitToSquad(requestingSquad, freeUnit);
-                delete unitTypeToHighestRequest[freeUnit.name];
-            } else if (grabRequests.length > 0) {
-                grabRequests.some((request) => {
-                    const { squad: requestingSquad } = request;
-                    if (
-                        freeUnit.rules.isSelectableCombatant &&
-                        getDistanceBetween(freeUnit, request.action.point) <= request.action.radius
-                    ) {
-                        this.logger(
-                            `granting unit ${freeUnit.id}#${
-                                freeUnit.name
-                            } to squad ${requestingSquad.getName()} via grab at ${request.action.point.x},${
-                                request.action.point.y
-                            }`,
+        type AssignmentWithType = { unitName: string; squad: string; method: "type" | "grab" };
+        // [squadName][unitName]['type' | 'grab']
+        const newAssignmentsByType = freeUnits
+            .flatMap((freeUnit) => {
+                if (unitTypeToHighestRequest.hasOwnProperty(freeUnit.name)) {
+                    const { squad: requestingSquad } = unitTypeToHighestRequest[freeUnit.name];
+                    this.logger(`granting unit ${freeUnit.id}#${freeUnit.name} to squad ${requestingSquad.getName()}`);
+                    this.addUnitToSquad(requestingSquad, freeUnit);
+                    delete unitTypeToHighestRequest[freeUnit.name];
+                    return [
+                        { unitName: freeUnit.name, squad: requestingSquad.getName(), method: "type" },
+                    ] as AssignmentWithType[];
+                } else if (grabRequests.length > 0) {
+                    const grantedSquad = grabRequests.find((request) => {
+                        return (
+                            freeUnit.rules.isSelectableCombatant &&
+                            getDistanceBetween(freeUnit, request.action.point) <= request.action.radius
                         );
-                        this.addUnitToSquad(requestingSquad, freeUnit);
-                        return true;
-                    } else {
-                        return false;
+                    });
+                    if (grantedSquad) {
+                        this.addUnitToSquad(grantedSquad.squad, freeUnit);
+                        return [
+                            { unitName: freeUnit.name, squad: grantedSquad.squad.getName(), method: "grab" },
+                        ] as AssignmentWithType[];
                     }
-                });
-            }
+                }
+                return [];
+            })
+            .reduce(
+                (acc, curr) => {
+                    if (!acc[curr.squad]) {
+                        acc[curr.squad] = {};
+                    }
+                    if (!acc[curr.squad][curr.unitName]) {
+                        acc[curr.squad][curr.unitName] = { grab: 0, type: 0 };
+                    }
+                    acc[curr.squad][curr.unitName][curr.method] = acc[curr.squad][curr.unitName][curr.method] + 1;
+                    return acc;
+                },
+                {} as Record<string, Record<string, Record<"type" | "grab", number>>>,
+            );
+        Object.entries(newAssignmentsByType).forEach(([squad, assignments]) => {
+            this.logger(
+                `Squad ${squad} received: ${Object.entries(assignments)
+                    .flatMap(([unitType, methodToCount]) =>
+                        Object.entries(methodToCount)
+                            .filter(([, count]) => count > 0)
+                            .map(([method, count]) => unitType + " x " + count + " (by " + method + ")"),
+                    )
+                    .join(", ")}`,
+            );
         });
     }
 

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

@@ -1,15 +1,15 @@
-// A periodically-refreshed cache of known threats to a bot so we can use it in decision making.
-
-export class GlobalThreat {
-    constructor(
-        public certainty: number, // 0.0 - 1.0 based on approximate visibility around the map.
-        public totalOffensiveLandThreat: number, // a number that approximates how much land-based firepower our opponents have.
-        public totalOffensiveAirThreat: number, // a number that approximates how much airborne firepower our opponents have.
-        public totalOffensiveAntiAirThreat: number, // a number that approximates how much anti-air firepower our opponents have.
-        public totalDefensiveThreat: number, // a number that approximates how much defensive power our opponents have.
-        public totalDefensivePower: number, // a number that approximates how much defensive power we have.
-        public totalAvailableAntiGroundFirepower: number, // how much anti-ground power we have
-        public totalAvailableAntiAirFirepower: number, // how much anti-air power we have
-        public totalAvailableAirPower: number, // how much firepower we have in air units
-    ) {}
-}
+// A periodically-refreshed cache of known threats to a bot so we can use it in decision making.
+
+export class GlobalThreat {
+    constructor(
+        public certainty: number, // 0.0 - 1.0 based on approximate visibility around the map.
+        public totalOffensiveLandThreat: number, // a number that approximates how much land-based firepower our opponents have.
+        public totalOffensiveAirThreat: number, // a number that approximates how much airborne firepower our opponents have.
+        public totalOffensiveAntiAirThreat: number, // a number that approximates how much anti-air firepower our opponents have.
+        public totalDefensiveThreat: number, // a number that approximates how much defensive power our opponents have.
+        public totalDefensivePower: number, // a number that approximates how much defensive power we have.
+        public totalAvailableAntiGroundFirepower: number, // how much anti-ground power we have
+        public totalAvailableAntiAirFirepower: number, // how much anti-air power we have
+        public totalAvailableAirPower: number, // how much firepower we have in air units
+    ) {}
+}