@supalosa/chronodivide-bot 0.3.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@supalosa/chronodivide-bot",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "description": "Example bot for Chrono Divide",
     "repository": "https://github.com/Supalosa/supalosa-chronodivide-bot",
     "main": "dist/exampleBot.js",
@@ -13,16 +13,16 @@
     },
     "license": "UNLICENSED",
     "devDependencies": {
-        "@chronodivide/game-api": "^0.46.0",
+        "@chronodivide/game-api": "^0.49.0",
         "@types/node": "^14.17.32",
         "prettier": "3.0.3",
         "typescript": "^4.3.5"
     },
     "peerDependencies": {
-        "@chronodivide/game-api": "^0.46.0"
+        "@chronodivide/game-api": "^0.49.0"
     },
     "dependencies": {
         "@datastructures-js/priority-queue": "^6.3.0",
-        "@timohausmann/quadtree-ts": "^2.0.0-beta.1"
+        "@timohausmann/quadtree-ts": "2.2.2"
     }
 }

package/src/bot/bot.ts

@@ -17,7 +17,7 @@ import { QUEUES, QueueController, queueTypeToName } from "./logic/building/queue
 import { MatchAwareness, MatchAwarenessImpl } from "./logic/awareness.js";
 import { formatTimeDuration } from "./logic/common/utils.js";
 
-const DEBUG_TIMESTAMP_OUTPUT_INTERVAL_SECONDS = 60;
+const DEBUG_STATE_UPDATE_INTERVAL_SECONDS = 6;
 
 // Number of ticks per second at the base speed.
 const NATURAL_TICK_RATE = 15;
@@ -33,14 +33,16 @@ export class SupalosaBot extends Bot {
 
     private matchAwareness: MatchAwareness | null = null;
 
-    private enableLogging: boolean;
-
-    constructor(name: string, country: string, enableLogging = true) {
+    constructor(
+        name: string,
+        country: string,
+        private tryAllyWith: string[] = [],
+        private enableLogging = true,
+    ) {
         super(name, country);
         this.missionController = new MissionController((message, sayInGame) => this.logBotStatus(message, sayInGame));
         this.squadController = new SquadController((message, sayInGame) => this.logBotStatus(message, sayInGame));
         this.queueController = new QueueController();
-        this.enableLogging = enableLogging;
     }
 
     override onGameStart(game: GameApi) {
@@ -61,6 +63,8 @@ export class SupalosaBot extends Bot {
         this.matchAwareness.onGameStart(game, myPlayer);
 
         this.logBotStatus(`Map bounds: ${this.knownMapBounds.width}, ${this.knownMapBounds.height}`);
+
+        this.tryAllyWith.forEach((playerName) => this.actionsApi.toggleAlliance(playerName, true));
     }
 
     override onGameTick(game: GameApi) {
@@ -70,8 +74,8 @@ export class SupalosaBot extends Bot {
 
         const threatCache = this.matchAwareness.getThreatCache();
 
-        if ((game.getCurrentTick() / NATURAL_TICK_RATE) % DEBUG_TIMESTAMP_OUTPUT_INTERVAL_SECONDS === 0) {
-            this.logDebugState(game);
+        if ((game.getCurrentTick() / NATURAL_TICK_RATE) % DEBUG_STATE_UPDATE_INTERVAL_SECONDS === 0) {
+            this.updateDebugState(game);
         }
 
         if (game.getCurrentTick() % this.tickRatio! === 0) {
@@ -138,10 +142,11 @@ export class SupalosaBot extends Bot {
         }
     }
 
-    private logDebugState(game: GameApi) {
-        if (!this.enableLogging) {
+    private updateDebugState(game: GameApi) {
+        if (!this.getDebugMode()) {
             return;
         }
+
         const myPlayer = game.getPlayerData(this.name);
         const queueState = QUEUES.reduce((prev, queueType) => {
             if (this.productionApi.getQueueData(queueType).size === 0) {
@@ -158,12 +163,18 @@ export class SupalosaBot extends Bot {
                 "]"
             );
         }, "");
-        this.logBotStatus(`----- Cash: ${myPlayer.credits} ----- | Queues: ${queueState}`);
+        let globalDebugText = `Cash: ${myPlayer.credits} | Queues: ${queueState}\n`;
         const harvesters = game.getVisibleUnits(this.name, "self", (r) => r.harvester).length;
-        this.logBotStatus(`Harvesters: ${harvesters}`);
-        this.squadController.debugSquads(this.gameApi);
-        this.logBotStatus(`----- End -----`);
+        globalDebugText += `Harvesters: ${harvesters}\n`;
+        globalDebugText += this.squadController.debugSquads(this.gameApi, this.actionsApi);
         this.missionController.logDebugOutput();
+
+        // Tag enemy units with IDs
+        game.getVisibleUnits(this.name, "hostile").forEach((unitId) => {
+            this.actionsApi.setUnitDebugText(unitId, unitId.toString());
+        });
+
+        this.actionsApi.setGlobalDebugText(globalDebugText);
     }
 
     override onGameEvent(ev: ApiEvent) {

package/src/bot/logic/building/antiGroundStaticDefence.ts

@@ -31,7 +31,7 @@ export class AntiGroundStaticDefence implements AiBuildingRules {
         }
         let selectedLocation =
             enemyFacingLocationCandidates[Math.floor(game.generateRandom() * enemyFacingLocationCandidates.length)];
-        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules, 0);
+        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules, false, 0);
     }
 
     getPriority(

package/src/bot/logic/building/buildingRules.ts

@@ -2,6 +2,7 @@ import {
     BuildingPlacementData,
     GameApi,
     GameMath,
+    LandType,
     ObjectType,
     PlayerData,
     Size,
@@ -51,21 +52,23 @@ export function numBuildingsOwnedOfName(game: GameApi, playerData: PlayerData, n
 }
 
 /**
- * Computes a rect 'centered' around a structure of a certain size with additional radius.
+ * Computes a rect 'centered' around a structure of a certain size with an additional radius (`adjacent`).
+ * The radius is optionally expanded by the size of the new building.
  *
- * This is essentially the placeable area around a given structure.
+ * This is essentially the candidate placement around a given structure.
  *
  * @param point Top-left location of the inner rect.
  * @param t Size of the inner rect.
- * @param adjacent Size of the outer rect.
+ * @param adjacent Amount to expand the building's inner rect by (so buildings must be adjacent by this many tiles)
+ * @param newBuildingSize? Size of the new building
  * @returns
  */
-function computeAdjacentRect(point: Vector2, t: Size, adjacent: number) {
+function computeAdjacentRect(point: Vector2, t: Size, adjacent: number, newBuildingSize?: Size) {
     return {
-        x: point.x - adjacent,
-        y: point.y - adjacent,
-        width: t.width + 2 * adjacent,
-        height: t.height + 2 * adjacent,
+        x: point.x - adjacent - (newBuildingSize?.width || 0),
+        y: point.y - adjacent - (newBuildingSize?.height || 0),
+        width: t.width + 2 * adjacent + (newBuildingSize?.width || 0),
+        height: t.height + 2 * adjacent + (newBuildingSize?.height || 0),
     };
 }
 
@@ -73,8 +76,9 @@ export function getAdjacencyTiles(
     game: GameApi,
     playerData: PlayerData,
     technoRules: TechnoRules,
+    onWater: boolean,
     minimumSpace: number,
-) {
+): Tile[] {
     const placementRules = game.getBuildingPlacementData(technoRules.name);
     const { width: newBuildingWidth, height: newBuildingHeight } = placementRules.foundation;
     const tiles = [];
@@ -82,44 +86,48 @@ export function getAdjacencyTiles(
     const removedTiles = new Set<string>();
     for (let buildingId of buildings) {
         const building = game.getUnitData(buildingId);
-        if (building?.rules?.baseNormal) {
-            const { foundation, tile } = building;
-            const buildingBase = new Vector2(tile.rx, tile.ry);
-            const buildingSize = {
-                width: foundation?.width,
-                height: foundation?.height,
-            };
-            const range = computeAdjacentRect(buildingBase, buildingSize, technoRules.adjacent);
-            const baseTile = game.mapApi.getTile(range.x, range.y);
-            if (!baseTile) {
-                continue;
-            }
-            const adjacentTiles = game.mapApi.getTilesInRect(baseTile, {
+        if (!building?.rules?.baseNormal) {
+            // This building is not considered for adjacency checks.
+            continue;
+        }
+        const { foundation, tile } = building;
+        const buildingBase = new Vector2(tile.rx, tile.ry);
+        const buildingSize = {
+            width: foundation?.width,
+            height: foundation?.height,
+        };
+        const range = computeAdjacentRect(buildingBase, buildingSize, technoRules.adjacent, placementRules.foundation);
+        const baseTile = game.mapApi.getTile(range.x, range.y);
+        if (!baseTile) {
+            continue;
+        }
+        const adjacentTiles = game.mapApi
+            .getTilesInRect(baseTile, {
                 width: range.width,
                 height: range.height,
-            });
-            tiles.push(...adjacentTiles);
-
-            // Prevent placing the new building on tiles that would cause it to overlap with this building.
-            const modifiedBase = new Vector2(
-                buildingBase.x - (newBuildingWidth - 1),
-                buildingBase.y - (newBuildingHeight - 1),
+            })
+            .filter((tile) => !onWater || tile.landType === LandType.Water);
+        tiles.push(...adjacentTiles);
+
+        // Prevent placing the new building on tiles that would cause it to overlap with this building.
+        const modifiedBase = new Vector2(
+            buildingBase.x - (newBuildingWidth - 1),
+            buildingBase.y - (newBuildingHeight - 1),
+        );
+        const modifiedSize = {
+            width: buildingSize.width + (newBuildingWidth - 1),
+            height: buildingSize.height + (newBuildingHeight - 1),
+        };
+        const blockedRect = computeAdjacentRect(modifiedBase, modifiedSize, minimumSpace);
+        const buildingTiles = adjacentTiles.filter((tile) => {
+            return (
+                tile.rx >= blockedRect.x &&
+                tile.rx < blockedRect.x + blockedRect.width &&
+                tile.ry >= blockedRect.y &&
+                tile.ry < blockedRect.y + blockedRect.height
             );
-            const modifiedSize = {
-                width: buildingSize.width + (newBuildingWidth - 1),
-                height: buildingSize.height + (newBuildingHeight - 1),
-            };
-            const blockedRect = computeAdjacentRect(modifiedBase, modifiedSize, minimumSpace);
-            const buildingTiles = adjacentTiles.filter((tile) => {
-                return (
-                    tile.rx >= blockedRect.x &&
-                    tile.rx < blockedRect.x + blockedRect.width &&
-                    tile.ry >= blockedRect.y &&
-                    tile.ry < blockedRect.y + blockedRect.height
-                );
-            });
-            buildingTiles.forEach((buildingTile) => removedTiles.add(buildingTile.id));
-        }
+        });
+        buildingTiles.forEach((buildingTile) => removedTiles.add(buildingTile.id));
     }
     // Remove duplicate tiles.
     const withDuplicatesRemoved = uniqBy(tiles, (tile) => tile.id);
@@ -151,17 +159,18 @@ function distance(x1: number, y1: number, x2: number, y2: number) {
 export function getDefaultPlacementLocation(
     game: GameApi,
     playerData: PlayerData,
-    startPoint: Vector2,
+    idealPoint: Vector2,
     technoRules: TechnoRules,
+    onWater: boolean = false,
     minSpace: number = 1,
 ): { rx: number; ry: number } | undefined {
-    // Random location, preferably near start location.
+    // Closest possible location near `startPoint`.
     const size: BuildingPlacementData = game.getBuildingPlacementData(technoRules.name);
     if (!size) {
         return undefined;
     }
-    const tiles = getAdjacencyTiles(game, playerData, technoRules, minSpace);
-    const tileDistances = getTileDistances(startPoint, tiles);
+    const tiles = getAdjacencyTiles(game, playerData, technoRules, onWater, minSpace);
+    const tileDistances = getTileDistances(idealPoint, tiles);
 
     for (let tileDistance of tileDistances) {
         if (tileDistance.tile && game.canPlaceBuilding(playerData.name, technoRules.name, tileDistance.tile)) {
@@ -186,6 +195,7 @@ export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
     ["ENGINEER", new BasicBuilding(10, 1, 1000)], // Engineer
     ["GADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
     ["GAAIRC", new BasicBuilding(10, 1, 500)], // Airforce Command
+    ["AMRADR", new BasicBuilding(10, 1, 500)], // Airforce Command (USA)
 
     ["GATECH", new BasicBuilding(20, 1, 4000)], // Allied Battle Lab
     ["GAYARD", new BasicBuilding(0, 0, 0)], // Naval Yard, disabled

package/src/bot/logic/building/queueController.ts

@@ -91,7 +91,9 @@ export class QueueController {
             if (!unit || !unit.hitPoints || !unit.maxHitPoints || unit.hasWrenchRepair) {
                 return;
             }
-            actionsApi.toggleRepairWrench(unitId);
+            if (unit.hitPoints < unit.maxHitPoints) {
+                actionsApi.toggleRepairWrench(unitId);
+            }
         });
     }
 
@@ -120,14 +122,20 @@ export class QueueController {
             // Consider placing it.
             const objectReady: TechnoRules = queueData.items[0].rules;
             if (queueType == QueueType.Structures || queueType == QueueType.Armory) {
-                logger(`Complete ${queueTypeToName(queueType)}: ${objectReady.name}`);
                 let location: { rx: number; ry: number } | undefined = this.getBestLocationForStructure(
                     game,
                     playerData,
                     objectReady,
                 );
                 if (location !== undefined) {
+                    logger(
+                        `Completed: ${queueTypeToName(queueType)}: ${objectReady.name}, placing at ${location.rx},${
+                            location.ry
+                        }`,
+                    );
                     actionsApi.placeBuilding(objectReady.name, location.rx, location.ry);
+                } else {
+                    logger(`Completed: ${queueTypeToName(queueType)}: ${objectReady.name} but nowhere to place it`);
                 }
             }
         } else if (queueData.status == QueueStatus.Active && queueData.items.length > 0 && decision != null) {

package/src/bot/logic/common/utils.ts

@@ -16,6 +16,8 @@ export function pad(n: any, format = "0000") {
     return format.substring(0, format.length - str.length) + str;
 }
 
+// So we don't need lodash
+
 export function maxBy<T>(array: T[], predicate: (arg: T) => number | null): T | null {
     if (array.length === 0) {
         return null;
@@ -63,3 +65,20 @@ export function countBy<T>(array: T[], predicate: (arg: T) => string | undefined
         {} as Record<string, number>,
     );
 }
+
+export function groupBy<K extends string, V>(array: V[], predicate: (arg: V) => K): { [key in K]: V[] } {
+    return array.reduce(
+        (prev, newVal) => {
+            const val = predicate(newVal);
+            if (val === undefined) {
+                return prev;
+            }
+            if (!prev.hasOwnProperty(val)) {
+                prev[val] = [];
+            }
+            prev[val].push(newVal);
+            return prev;
+        },
+        {} as Record<K, V[]>,
+    );
+}

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

@@ -1,4 +1,4 @@
-import { GameApi, ObjectType, PlayerData, UnitData, Vector2 } from "@chronodivide/game-api";
+import { GameApi, GameMath, MapApi, ObjectType, PlayerData, UnitData, Vector2 } from "@chronodivide/game-api";
 import { CombatSquad } from "../../squad/behaviours/combatSquad.js";
 import { Mission, MissionAction, disbandMission, noop } from "../mission.js";
 import { Squad } from "../../squad/squad.js";
@@ -13,13 +13,16 @@ export enum AttackFailReason {
     DefenceTooStrong = 1,
 }
 
-const NO_TARGET_IDLE_TIMEOUT_TICKS = 60;
+const NO_TARGET_RETARGET_TICKS = 450;
+const NO_TARGET_IDLE_TIMEOUT_TICKS = 900;
 
 /**
  * A mission that tries to attack a certain area.
  */
 export class AttackMission extends Mission<AttackFailReason> {
     private lastTargetSeenAt = 0;
+    private behaviour: CombatSquad | undefined;
+    private hasPickedNewTarget: boolean = false;
 
     constructor(
         uniqueName: string,
@@ -34,9 +37,8 @@ export class AttackMission extends Mission<AttackFailReason> {
 
     onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
         if (this.getSquad() === null) {
-            return this.setSquad(
-                new Squad(this.getUniqueName(), new CombatSquad(this.rallyArea, this.attackArea, this.radius), this),
-            );
+            this.behaviour = new CombatSquad(this.rallyArea, this.attackArea, this.radius);
+            return this.setSquad(new Squad(this.getUniqueName(), this.behaviour, this));
         } else {
             // Dispatch missions.
             if (!matchAwareness.shouldAttack()) {
@@ -47,16 +49,24 @@ export class AttackMission extends Mission<AttackFailReason> {
 
             if (foundTargets.length > 0) {
                 this.lastTargetSeenAt = gameApi.getCurrentTick();
+                this.hasPickedNewTarget = false;
             } else if (gameApi.getCurrentTick() > this.lastTargetSeenAt + NO_TARGET_IDLE_TIMEOUT_TICKS) {
                 return disbandMission(AttackFailReason.NoTargets);
+            } else if (
+                !this.hasPickedNewTarget &&
+                gameApi.getCurrentTick() > this.lastTargetSeenAt + NO_TARGET_RETARGET_TICKS
+            ) {
+                const newTarget = generateTarget(gameApi, playerData, matchAwareness);
+                if (newTarget) {
+                    this.behaviour?.setAttackArea(newTarget);
+                    this.hasPickedNewTarget = true;
+                }
             }
         }
         return noop();
     }
 }
 
-const ATTACK_COOLDOWN_TICKS = 120;
-
 // Calculates the weight for initiating an attack on the position of a unit or building.
 // This is separate from unit micro; the squad will be ordered to attack in the vicinity of the point.
 const getTargetWeight: (unitData: UnitData, tryFocusHarvester: boolean) => number = (unitData, tryFocusHarvester) => {
@@ -69,33 +79,63 @@ const getTargetWeight: (unitData: UnitData, tryFocusHarvester: boolean) => numbe
     }
 };
 
+function generateTarget(
+    gameApi: GameApi,
+    playerData: PlayerData,
+    matchAwareness: MatchAwareness,
+    includeBaseLocations: boolean = false,
+): Vector2 | null {
+    // Randomly decide between harvester and base.
+    try {
+        const tryFocusHarvester = gameApi.generateRandomInt(0, 1) === 0;
+        const enemyUnits = gameApi
+            .getVisibleUnits(playerData.name, "hostile")
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((u) => !!u && gameApi.getPlayerData(u.owner).isCombatant) as UnitData[];
+
+        const maxUnit = maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
+        if (maxUnit) {
+            return new Vector2(maxUnit.tile.rx, maxUnit.tile.ry);
+        }
+        if (includeBaseLocations) {
+            const mapApi = gameApi.mapApi;
+            const enemyPlayers = gameApi
+                .getPlayers()
+                .map(gameApi.getPlayerData)
+                .filter((otherPlayer) => !gameApi.areAlliedPlayers(playerData.name, otherPlayer.name));
+
+            const unexploredEnemyLocations = enemyPlayers.filter((otherPlayer) => {
+                const tile = mapApi.getTile(otherPlayer.startLocation.x, otherPlayer.startLocation.y);
+                if (!tile) {
+                    return false;
+                }
+                return !mapApi.isVisibleTile(tile, playerData.name);
+            });
+            if (unexploredEnemyLocations.length > 0) {
+                const idx = gameApi.generateRandomInt(0, unexploredEnemyLocations.length - 1);
+                return unexploredEnemyLocations[idx].startLocation;
+            }
+        }
+    } catch (err) {
+        // There's a crash here when accessing a building that got destroyed. Will catch and ignore or now.
+        return null;
+    }
+    return null;
+}
+
+// Number of ticks between attacking visible targets.
+const VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS = 120;
+
+// Number of ticks between attacking "bases" (enemy starting locations).
+const BASE_ATTACK_COOLDOWN_TICKS = 1800;
+
 export class AttackMissionFactory implements MissionFactory {
-    constructor(private lastAttackAt: number = -ATTACK_COOLDOWN_TICKS) {}
+    constructor(private lastAttackAt: number = -VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS) {}
 
     getName(): string {
         return "AttackMissionFactory";
     }
 
-    generateTarget(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): Vector2 | null {
-        // Randomly decide between harvester and base.
-        try {
-            const tryFocusHarvester = gameApi.generateRandomInt(0, 1) === 0;
-            const enemyUnits = gameApi
-                .getVisibleUnits(playerData.name, "hostile")
-                .map((unitId) => gameApi.getUnitData(unitId))
-                .filter((u) => !!u && gameApi.getPlayerData(u.owner).isCombatant) as UnitData[];
-
-            const maxUnit = maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
-            if (maxUnit) {
-                return new Vector2(maxUnit.tile.rx, maxUnit.tile.ry);
-            }
-        } catch (err) {
-            // There's a crash here when accessing a building that got destroyed. Will catch and ignore or now.
-            return null;
-        }
-        return null;
-    }
-
     maybeCreateMissions(
         gameApi: GameApi,
         playerData: PlayerData,
@@ -106,16 +146,17 @@ export class AttackMissionFactory implements MissionFactory {
         if (!matchAwareness.shouldAttack()) {
             return;
         }
-        if (gameApi.getCurrentTick() < this.lastAttackAt + ATTACK_COOLDOWN_TICKS) {
+        if (gameApi.getCurrentTick() < this.lastAttackAt + VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS) {
             return;
         }
 
         const attackRadius = 15;
 
-        const attackArea = this.generateTarget(gameApi, playerData, matchAwareness);
+        const includeEnemyBases = gameApi.getCurrentTick() > this.lastAttackAt + BASE_ATTACK_COOLDOWN_TICKS;
+
+        const attackArea = generateTarget(gameApi, playerData, matchAwareness, includeEnemyBases);
 
         if (!attackArea) {
-            // Nothing to attack.
             return;
         }
 

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

@@ -0,0 +1,65 @@
+// Used to group related actions together to minimise actionApi calls. For example, if multiple units
+
+import { ActionsApi, OrderType, Vector2 } from "@chronodivide/game-api";
+import { groupBy } from "../../common/utils.js";
+
+// are ordered to move to the same location, all of them will be ordered to move in a single action.
+export type BatchableAction = {
+    unitId: number;
+    orderType: OrderType;
+    point?: Vector2;
+    targetId?: number;
+};
+
+export class ActionBatcher {
+    private actions: BatchableAction[];
+
+    constructor() {
+        this.actions = [];
+    }
+
+    push(action: BatchableAction) {
+        this.actions.push(action);
+    }
+
+    resolve(actionsApi: ActionsApi) {
+        const groupedCommands = groupBy(this.actions, (action) => action.orderType.valueOf().toString());
+        const vectorToStr = (v: Vector2) => v.x + "," + v.y;
+        const strToVector = (str: string) => {
+            const [x, y] = str.split(",");
+            return new Vector2(parseInt(x), parseInt(y));
+        };
+
+        // Group by command type.
+        Object.entries(groupedCommands).forEach(([commandValue, commands]) => {
+            // i hate this
+            const commandType: OrderType = parseInt(commandValue) as OrderType;
+            // Group by command target ID.
+            const byTarget = groupBy(
+                commands.filter((command) => !!command.targetId),
+                (command) => command.targetId?.toString()!,
+            );
+            Object.entries(byTarget).forEach(([targetId, unitCommands]) => {
+                actionsApi.orderUnits(
+                    unitCommands.map((command) => command.unitId),
+                    commandType,
+                    parseInt(targetId),
+                );
+            });
+            // Group by position (the vector is encoded as a string of the form "x,y")
+            const byPosition = groupBy(
+                commands.filter((command) => !!command.point),
+                (command) => vectorToStr(command.point!),
+            );
+            Object.entries(byPosition).forEach(([point, unitCommands]) => {
+                const vector = strToVector(point);
+                actionsApi.orderUnits(
+                    unitCommands.map((command) => command.unitId),
+                    commandType,
+                    vector.x,
+                    vector.y,
+                );
+            });
+        });
+    }
+}

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

@@ -4,6 +4,7 @@ import { SquadAction, SquadBehaviour, grabCombatants, noop } from "../squadBehav
 import { MatchAwareness } from "../../awareness.js";
 import { getAttackWeight, manageAttackMicro, manageMoveMicro } from "./common.js";
 import { DebugLogger, maxBy } from "../../common/utils.js";
+import { ActionBatcher } from "./actionBatcher.js";
 
 const TARGET_UPDATE_INTERVAL_TICKS = 10;
 const GRAB_INTERVAL_TICKS = 10;
@@ -29,6 +30,8 @@ export class CombatSquad implements SquadBehaviour {
     private lastCommand: number | null = null;
     private state = SquadState.Gathering;
 
+    private debugLastTarget: string | undefined;
+
     /**
      *
      * @param rallyArea the initial location to grab combatants
@@ -41,6 +44,10 @@ export class CombatSquad implements SquadBehaviour {
         private radius: number,
     ) {}
 
+    public getGlobalDebugText(): string | undefined {
+        return this.debugLastTarget ?? "<none>";
+    }
+
     public setAttackArea(targetArea: Vector2) {
         this.targetArea = targetArea;
     }
@@ -48,6 +55,7 @@ export class CombatSquad implements SquadBehaviour {
     public onAiUpdate(
         gameApi: GameApi,
         actionsApi: ActionsApi,
+        actionBatcher: ActionBatcher,
         playerData: PlayerData,
         squad: Squad,
         matchAwareness: MatchAwareness,
@@ -81,7 +89,7 @@ export class CombatSquad implements SquadBehaviour {
                     maxDistance > requiredGatherRadius
                 ) {
                     units.forEach((unit) => {
-                        manageMoveMicro(actionsApi, unit, centerOfMass);
+                        actionBatcher.push(manageMoveMicro(unit, centerOfMass));
                     });
                 } else {
                     logger(`CombatSquad ${squad.getName()} switching back to attack mode (${maxDistance})`);
@@ -109,9 +117,11 @@ export class CombatSquad implements SquadBehaviour {
                         .map(({ unitId }) => gameApi.getUnitData(unitId)) as UnitData[];
                     const bestUnit = maxBy(nearbyHostiles, (target) => getAttackWeight(unit, target));
                     if (bestUnit) {
-                        manageAttackMicro(actionsApi, unit, bestUnit);
+                        actionBatcher.push(manageAttackMicro(unit, bestUnit));
+                        this.debugLastTarget = `Unit ${bestUnit.id.toString()}`;
                     } else {
-                        manageMoveMicro(actionsApi, unit, targetPoint);
+                        actionBatcher.push(manageMoveMicro(unit, targetPoint));
+                        this.debugLastTarget = `@${targetPoint.x},${targetPoint.y}`;
                     }
                 }
             }