@supalosa/chronodivide-bot 0.2.1 → 0.2.2-a

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 {
@@ -93,23 +99,21 @@ 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();
                 }
                 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,5 +1,15 @@
-import { ActionsApi, AttackState, ObjectType, OrderType, Point2D, StanceType, 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) {
@@ -37,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/scoutingSquad.ts

@@ -1,17 +1,29 @@
-import { ActionsApi, GameApi, OrderType, PlayerData, Point2D, SideType } from "@chronodivide/game-api";
-import { GlobalThreat } from "../../threat/threat.js";
+import { ActionsApi, GameApi, OrderType, PlayerData, Point2D } from "@chronodivide/game-api";
 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 { DebugLogger } from "../../common/utils.js";
+import { getDistanceBetweenPoints } 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 +31,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 +41,69 @@ 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 distances = scouts.map((unit) =>
+                    getDistanceBetweenPoints({ x: unit.tile.rx, y: unit.tile.ry }, this.scoutTarget!),
+                );
+                const newMinDistance = Math.min(...distances);
+                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

@@ -4,7 +4,7 @@ import { GlobalThreat } from "../threat/threat.js";
 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,
@@ -41,7 +41,7 @@ const calculateCenterOfMass: (unitTiles: Tile[]) => {
 
     // max distance of units to the center of mass
     const distances = unitTiles.map((tile) => getDistanceBetweenPoints({ x: tile.rx, y: tile.ry }, centerOfMass));
-    const maxDistance = _.max(distances)!;
+    const maxDistance = Math.max(...distances);
     return { centerOfMass, maxDistance };
 };
 
@@ -76,6 +76,7 @@ export class Squad {
         actionsApi: ActionsApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
+        logger: DebugLogger,
     ): SquadAction {
         this.updateLiveness(gameApi);
         const movableUnitTiles = this.unitIds
@@ -100,8 +101,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

@@ -1,7 +1,6 @@
 // Meta-controller for forming and controlling squads.
 
 import { ActionsApi, GameApi, PlayerData, UnitData } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
 import { Squad, SquadLiveness } from "./squad.js";
 import {
     SquadAction,
@@ -13,7 +12,7 @@ import {
 } from "./squadBehaviour.js";
 import { MatchAwareness } from "../awareness.js";
 import { getDistanceBetween } from "../map/map.js";
-import _ from "lodash";
+import countBy from "lodash.countby";
 
 type SquadWithAction<T> = {
     squad: Squad;
@@ -51,7 +50,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 +104,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 +178,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(", ")}`,
+            );
         });
     }
 
@@ -197,7 +242,7 @@ export class SquadController {
     }
 
     public debugSquads(gameApi: GameApi) {
-        const unitsInSquad = (unitIds: number[]) => _.countBy(unitIds, (unitId) => gameApi.getUnitData(unitId)?.name);
+        const unitsInSquad = (unitIds: number[]) => countBy(unitIds, (unitId) => gameApi.getUnitData(unitId)?.name);
 
         this.squads.forEach((squad) => {
             this.logger(

package/src/exampleBot.ts

@@ -6,17 +6,17 @@ async function main() {
     Ladder maps:
     CDR2            1v1             2_malibu_cliffs_le.map
     CDR2            1v1             4_country_swing_le_v2.map
-    CDR2            1v1             mp01t4.map
-    CDR2            1v1             tn04t2.map
-    CDR2            1v1             mp10s4.map
+    CDR2            1v1             mp01t4.map, large map, oil derricks
+    CDR2            1v1             tn04t2.map, small map
+    CDR2            1v1             mp10s4.map <- depth charge, naval map (not supported)
     CDR2            1v1             heckcorners.map
     CDR2            1v1             4_montana_dmz_le.map
     CDR2            1v1             barrel.map
     
     Other maps:
-    mp03t4
+    mp03t4 large map, no oil derricks
     */
-    const mapName = "mp01t4.map";
+    const mapName = "tn04t2.map";
     // Bot names must be unique in online mode
     const botName = `Joe${String(Date.now()).substr(-6)}`;
     const otherBotName = `Bob${String(Date.now() + 1).substr(-6)}`;
@@ -48,7 +48,7 @@ async function main() {
     };
 
     const offlineSettings = {
-        agents: [new SupalosaBot(botName, "French", false), new SupalosaBot(otherBotName, "French", true)],
+        agents: [new SupalosaBot(botName, "French", false), new SupalosaBot(otherBotName, "Russians", true)],
     };
 
     const game = await cdapi.createGame({