@supalosa/chronodivide-bot 0.2.0 → 0.2.2

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 {
@@ -92,7 +95,8 @@ 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();
                 }

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

@@ -1,10 +1,11 @@
-import { ActionsApi, ObjectType, OrderType, Point2D, UnitData } from "@chronodivide/game-api";
+import { ActionsApi, AttackState, ObjectType, OrderType, Point2D, StanceType, 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) {
+        const isDeployed = attacker.stance === StanceType.Deployed;
+        if (isDeployed) {
             actionsApi.orderUnits([attacker.id], OrderType.DeploySelected);
         }
     }
@@ -16,10 +17,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;
         }

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);
         }
     }
 }

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

@@ -13,6 +13,8 @@ import {
 } from "./squadBehaviour.js";
 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;
@@ -23,14 +25,13 @@ export class SquadController {
     private squads: Squad[] = [];
     private unitIdToSquad: Map<number, Squad> = new Map();
 
-    constructor() {}
+    constructor(private logger: (message: string, sayInGame?: boolean) => void) {}
 
     public onAiUpdate(
         gameApi: GameApi,
         actionsApi: ActionsApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
-        logger: (message: string) => void
     ) {
         // Remove dead squads or those where the mission is dead.
         this.squads = this.squads.filter((squad) => squad.getLiveness() !== SquadLiveness.SquadDead);
@@ -41,7 +42,7 @@ export class SquadController {
         this.squads.forEach((squad) => {
             squad.getUnitIds().forEach((unitId) => {
                 if (this.unitIdToSquad.has(unitId)) {
-                    logger(`WARNING: unit ${unitId} is in multiple squads, please debug.`);
+                    this.logger(`WARNING: unit ${unitId} is in multiple squads, please debug.`);
                 } else {
                     this.unitIdToSquad.set(unitId, 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.
@@ -61,7 +62,7 @@ export class SquadController {
         squadActions
             .filter((a) => isDisband(a.action))
             .forEach((a) => {
-                logger(`Squad ${a.squad.getName()} disbanding as requested.`);
+                this.logger(`Squad ${a.squad.getName()} disbanding as requested.`);
                 a.squad.getMission()?.removeSquad();
                 a.squad.getUnitIds().forEach((unitId) => {
                     this.unitIdToSquad.delete(unitId);
@@ -73,8 +74,8 @@ export class SquadController {
             .forEach((a) => {
                 let mergeInto = a.action as SquadActionMergeInto;
                 if (disbandedSquads.has(mergeInto.mergeInto.getName())) {
-                    logger(
-                        `Squad ${a.squad.getName()} tried to merge into disbanded squad ${mergeInto.mergeInto.getName()}, cancelling.`
+                    this.logger(
+                        `Squad ${a.squad.getName()} tried to merge into disbanded squad ${mergeInto.mergeInto.getName()}, cancelling.`,
                     );
                     return;
                 }
@@ -88,58 +89,88 @@ export class SquadController {
         const isRequestSpecific = (a: SquadAction) => a.type === "requestSpecific";
         const unitIdToHighestRequest = squadActions
             .filter((a) => isRequestSpecific(a.action))
-            .reduce((prev, a) => {
-                const squadWithAction = a as SquadWithAction<SquadActionRequestSpecificUnits>;
-                const { unitIds } = squadWithAction.action;
-                unitIds.forEach((unitId) => {
-                    if (prev.hasOwnProperty(unitId)) {
-                        if (prev[unitId].action.priority > prev[unitId].action.priority) {
+            .reduce(
+                (prev, a) => {
+                    const squadWithAction = a as SquadWithAction<SquadActionRequestSpecificUnits>;
+                    const { unitIds } = squadWithAction.action;
+                    unitIds.forEach((unitId) => {
+                        if (prev.hasOwnProperty(unitId)) {
+                            if (prev[unitId].action.priority > prev[unitId].action.priority) {
+                                prev[unitId] = squadWithAction;
+                            }
+                        } else {
                             prev[unitId] = squadWithAction;
                         }
-                    } else {
-                        prev[unitId] = squadWithAction;
+                    });
+                    return prev;
+                },
+                {} as Record<number, SquadWithAction<SquadActionRequestSpecificUnits>>,
+            );
+
+        // 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] = {};
                     }
-                });
-                return prev;
-            }, {} 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) {
-                logger(`mission ${missionName} requested non-existent unit ${unitId}`);
-                return;
-            }
-            if (!this.unitIdToSquad.has(unitId)) {
-                logger(`granting specific unit ${unitId} to squad ${requestingSquad.getName()} in mission ${missionName}`);
-                this.addUnitToSquad(requestingSquad, unit);
-            }
+                    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
         const isRequest = (a: SquadAction) => a.type === "request";
         const unitTypeToHighestRequest = squadActions
             .filter((a) => isRequest(a.action))
-            .reduce((prev, a) => {
-                const squadWithAction = a as SquadWithAction<SquadActionRequestUnits>;
-                const { unitNames } = squadWithAction.action;
-                unitNames.forEach((unitName) => {
-                    if (prev.hasOwnProperty(unitName)) {
-                        if (prev[unitName].action.priority > prev[unitName].action.priority) {
+            .reduce(
+                (prev, a) => {
+                    const squadWithAction = a as SquadWithAction<SquadActionRequestUnits>;
+                    const { unitNames } = squadWithAction.action;
+                    unitNames.forEach((unitName) => {
+                        if (prev.hasOwnProperty(unitName)) {
+                            if (prev[unitName].action.priority > prev[unitName].action.priority) {
+                                prev[unitName] = squadWithAction;
+                            }
+                        } else {
                             prev[unitName] = squadWithAction;
                         }
-                    } else {
-                        prev[unitName] = squadWithAction;
-                    }
-                });
-                return prev;
-            }, {} as Record<string, SquadWithAction<SquadActionRequestUnits>>);
+                    });
+                    return prev;
+                },
+                {} as Record<string, SquadWithAction<SquadActionRequestUnits>>,
+            );
 
         // Request combat-capable units in an area
         const isGrab = (a: SquadAction) => a.type === "requestCombatants";
         const grabRequests = squadActions.filter((a) =>
-            isGrab(a.action)
+            isGrab(a.action),
         ) as SquadWithAction<SquadActionGrabFreeCombatants>[];
 
         // Find loose units
@@ -149,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];
-                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
-                    ) {
-                        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(", ")}`,
+            );
         });
     }
 
@@ -187,4 +242,16 @@ export class SquadController {
     public registerSquad(squad: Squad) {
         this.squads.push(squad);
     }
+
+    public debugSquads(gameApi: GameApi) {
+        const unitsInSquad = (unitIds: number[]) => _.countBy(unitIds, (unitId) => gameApi.getUnitData(unitId)?.name);
+
+        this.squads.forEach((squad) => {
+            this.logger(
+                `Squad ${squad.getName()}: ${Object.entries(unitsInSquad(squad.getUnitIds()))
+                    .map(([unitName, count]) => `${unitName} x ${count}`)
+                    .join(", ")}`,
+            );
+        });
+    }
 }