@supalosa/chronodivide-bot 0.1.1 → 0.2.0

package/dist/bot/logic/squad/behaviours/combatSquad.js

@@ -0,0 +1,99 @@
+import _ from "lodash";
+import { MovementZone } from "@chronodivide/game-api";
+import { grabCombatants, noop } from "../squadBehaviour.js";
+import { getDistanceBetweenPoints } from "../../map/map.js";
+import { manageAttackMicro, manageMoveMicro } from "./common.js";
+const TARGET_UPDATE_INTERVAL_TICKS = 10;
+const GRAB_INTERVAL_TICKS = 10;
+const GRAB_RADIUS = 20;
+// Units must be in a certain radius of the center of mass before attacking.
+// This scales for number of units in the squad though.
+const MIN_GATHER_RADIUS = 5;
+// If the radius expands beyond this amount then we should switch back to gathering mode.
+const MAX_GATHER_RADIUS = 15;
+const GATHER_RATIO = 10;
+var SquadState;
+(function (SquadState) {
+    SquadState[SquadState["Gathering"] = 0] = "Gathering";
+    SquadState[SquadState["Attacking"] = 1] = "Attacking";
+})(SquadState || (SquadState = {}));
+export class CombatSquad {
+    /**
+     *
+     * @param rallyArea the initial location to grab combatants
+     * @param targetArea
+     * @param radius
+     */
+    constructor(rallyArea, targetArea, radius) {
+        this.rallyArea = rallyArea;
+        this.targetArea = targetArea;
+        this.radius = radius;
+        this.lastGrab = null;
+        this.lastCommand = null;
+        this.state = SquadState.Gathering;
+    }
+    setAttackArea(targetArea) {
+        this.targetArea = targetArea;
+    }
+    onAiUpdate(gameApi, actionsApi, playerData, squad, matchAwareness) {
+        if (!this.lastCommand || gameApi.getCurrentTick() > this.lastCommand + TARGET_UPDATE_INTERVAL_TICKS) {
+            this.lastCommand = gameApi.getCurrentTick();
+            const centerOfMass = squad.getCenterOfMass();
+            const maxDistance = squad.getMaxDistanceToCenterOfMass();
+            const units = squad.getUnitsMatching(gameApi, (r) => r.rules.isSelectableCombatant);
+            // Only use ground units for center of mass.
+            const groundUnits = squad.getUnitsMatching(gameApi, (r) => r.rules.isSelectableCombatant &&
+                (r.rules.movementZone === MovementZone.Infantry ||
+                    r.rules.movementZone === MovementZone.Normal ||
+                    r.rules.movementZone === MovementZone.InfantryDestroyer));
+            if (this.state === SquadState.Gathering) {
+                const requiredGatherRadius = Math.sqrt(groundUnits.length) * GATHER_RATIO + MIN_GATHER_RADIUS;
+                if (centerOfMass &&
+                    maxDistance &&
+                    gameApi.mapApi.getTile(centerOfMass.x, centerOfMass.y) !== undefined &&
+                    maxDistance > requiredGatherRadius) {
+                    units.forEach((unit) => {
+                        manageMoveMicro(actionsApi, unit, centerOfMass);
+                    });
+                }
+                else {
+                    this.state = SquadState.Attacking;
+                }
+            }
+            else {
+                const targetPoint = this.targetArea || playerData.startLocation;
+                const requiredGatherRadius = Math.sqrt(groundUnits.length) * GATHER_RATIO + MAX_GATHER_RADIUS;
+                if (centerOfMass &&
+                    maxDistance &&
+                    gameApi.mapApi.getTile(centerOfMass.x, centerOfMass.y) !== undefined &&
+                    maxDistance > requiredGatherRadius) {
+                    // Switch back to gather mode.
+                    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);
+                        }
+                    }
+                }
+            }
+        }
+        if (!this.lastGrab || gameApi.getCurrentTick() > this.lastGrab + GRAB_INTERVAL_TICKS) {
+            this.lastGrab = gameApi.getCurrentTick();
+            return grabCombatants(squad.getCenterOfMass() ?? this.rallyArea, GRAB_RADIUS);
+        }
+        else {
+            return noop();
+        }
+    }
+}

package/dist/bot/logic/squad/behaviours/common.js

@@ -0,0 +1,37 @@
+import { ObjectType, OrderType } from "@chronodivide/game-api";
+import { getDistanceBetweenUnits } from "../../map/map.js";
+// Micro methods
+export function manageMoveMicro(actionsApi, attacker, attackPoint) {
+    if (attacker.name === "E1") {
+        if (!attacker.canMove) {
+            actionsApi.orderUnits([attacker.id], OrderType.DeploySelected);
+        }
+    }
+    actionsApi.orderUnits([attacker.id], OrderType.Move, attackPoint.x, attackPoint.y);
+}
+export function manageAttackMicro(actionsApi, attacker, target) {
+    const distance = getDistanceBetweenUnits(attacker, target);
+    if (attacker.name === "E1") {
+        // Para (deployed weapon) range is 5.
+        const deployedWeaponRange = attacker.secondaryWeapon?.maxRange || 5;
+        if (attacker.canMove && distance <= deployedWeaponRange * 0.8) {
+            actionsApi.orderUnits([attacker.id], OrderType.DeploySelected);
+            return;
+        }
+        else if (!attacker.canMove && distance > deployedWeaponRange) {
+            actionsApi.orderUnits([attacker.id], OrderType.DeploySelected);
+            return;
+        }
+    }
+    let targetData = target;
+    let orderType = OrderType.Attack;
+    const primaryWeaponRange = attacker.primaryWeapon?.maxRange || 5;
+    if (targetData?.type == ObjectType.Building && distance < primaryWeaponRange * 0.8) {
+        orderType = OrderType.Attack;
+    }
+    else if (targetData?.rules.canDisguise) {
+        // Special case for mirage tank/spy as otherwise they just sit next to it.
+        orderType = OrderType.Attack;
+    }
+    actionsApi.orderUnits([attacker.id], orderType, target.id);
+}

package/dist/bot/logic/squad/behaviours/defenceSquad.js

@@ -0,0 +1,48 @@
+import _ from "lodash";
+import { disband, grabCombatants } from "../squadBehaviour.js";
+import { getDistanceBetween, getDistanceBetweenUnits } from "../../map/map.js";
+import { manageAttackMicro } from "./common.js";
+// If no enemies are seen in a circle IDLE_CHECK_RADIUS*radius for IDLE_COOLDOWN_TICKS ticks, the mission is disbanded.
+const IDLE_CHECK_RADIUS_RATIO = 2;
+const IDLE_COOLDOWN_TICKS = 15 * 30;
+const GRAB_RADIUS = 2;
+export class DefenceSquad {
+    constructor(defenceArea, radius) {
+        this.defenceArea = defenceArea;
+        this.radius = radius;
+        this.lastIdleCheck = null;
+    }
+    onAiUpdate(gameApi, actionsApi, playerData, squad, matchAwareness) {
+        const enemyUnits = gameApi.getVisibleUnits(playerData.name, "hostile", (r) => r.isSelectableCombatant);
+        const hasEnemiesInIdleCheckRadius = enemyUnits
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .some((unit) => !!unit &&
+            unit.tile &&
+            getDistanceBetween(unit, this.defenceArea) < IDLE_CHECK_RADIUS_RATIO * this.radius);
+        if (this.lastIdleCheck === null) {
+            this.lastIdleCheck = gameApi.getCurrentTick();
+        }
+        else if (!hasEnemiesInIdleCheckRadius &&
+            gameApi.getCurrentTick() > this.lastIdleCheck + IDLE_COOLDOWN_TICKS) {
+            return disband();
+        }
+        const enemiesInRadius = enemyUnits
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => !!unit && unit.tile && getDistanceBetween(unit, this.defenceArea) < this.radius)
+            .map((unit) => unit);
+        const defenders = squad.getUnitsMatching(gameApi, (r) => r.rules.isSelectableCombatant);
+        defenders.forEach((defender) => {
+            // Find closest attacking unit
+            if (defender.isIdle) {
+                const closestEnemy = _.minBy(enemiesInRadius.map((enemy) => ({
+                    enemy,
+                    distance: getDistanceBetweenUnits(defender, enemy),
+                })), "distance");
+                if (closestEnemy) {
+                    manageAttackMicro(actionsApi, defender, closestEnemy.enemy);
+                }
+            }
+        });
+        return grabCombatants(this.defenceArea, this.radius * GRAB_RADIUS);
+    }
+}

package/dist/bot/logic/squad/behaviours/expansionSquad.js

@@ -0,0 +1,42 @@
+import { OrderType } from "@chronodivide/game-api";
+import { disband, noop, requestSpecificUnits, requestUnits } from "../squadBehaviour.js";
+const DEPLOY_COOLDOWN_TICKS = 30;
+// Expansion or initial base.
+export class ExpansionSquad {
+    /**
+     * @param selectedMcv ID of the MCV to try to expand with. If that unit dies, the squad will disband. If no value is provided,
+     * the mission requests an MCV.
+     */
+    constructor(selectedMcv) {
+        this.selectedMcv = selectedMcv;
+        this.hasAttemptedDeployWith = null;
+    }
+    ;
+    onAiUpdate(gameApi, actionsApi, playerData, squad, matchAwareness) {
+        const mcvTypes = ["AMCV", "SMCV"];
+        const mcvs = squad.getUnitsOfTypes(gameApi, ...mcvTypes);
+        if (mcvs.length === 0) {
+            // Perhaps we deployed already (or the unit was destroyed), end the mission.
+            if (this.hasAttemptedDeployWith !== null) {
+                return disband();
+            }
+            // We need an mcv!
+            if (this.selectedMcv) {
+                return requestSpecificUnits([this.selectedMcv], 100);
+            }
+            else {
+                return requestUnits(mcvTypes, 100);
+            }
+        }
+        else if (!this.hasAttemptedDeployWith ||
+            gameApi.getCurrentTick() > this.hasAttemptedDeployWith.gameTick + DEPLOY_COOLDOWN_TICKS) {
+            actionsApi.orderUnits(mcvs.map((mcv) => mcv.id), OrderType.DeploySelected);
+            // Add a cooldown to deploy attempts.
+            this.hasAttemptedDeployWith = {
+                unitId: mcvs[0].id,
+                gameTick: gameApi.getCurrentTick(),
+            };
+        }
+        return noop();
+    }
+}

package/dist/bot/logic/squad/behaviours/retreatSquad.js

@@ -0,0 +1,32 @@
+import { OrderType } from "@chronodivide/game-api";
+import { disband, requestSpecificUnits } from "../squadBehaviour.js";
+const SCOUT_MOVE_COOLDOWN_TICKS = 30;
+export class RetreatSquad {
+    constructor(unitIds, retreatToPoint) {
+        this.unitIds = unitIds;
+        this.retreatToPoint = retreatToPoint;
+        this.hasRequestedUnits = false;
+        this.moveOrderSentAt = null;
+        this.createdAt = null;
+    }
+    onAiUpdate(gameApi, actionsApi, playerData, squad, matchAwareness) {
+        if (!this.createdAt) {
+            this.createdAt = gameApi.getCurrentTick();
+        }
+        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();
+            }
+        }
+        if ((this.moveOrderSentAt && gameApi.getCurrentTick() > this.moveOrderSentAt + 60) ||
+            (this.createdAt && gameApi.getCurrentTick() > this.createdAt + 240)) {
+            return disband();
+        }
+        else {
+            return requestSpecificUnits(this.unitIds, 100);
+        }
+    }
+}

package/dist/bot/logic/squad/behaviours/scoutingSquad.js

@@ -0,0 +1,38 @@
+import { OrderType } from "@chronodivide/game-api";
+import { disband, noop, requestUnits } from "../squadBehaviour.js";
+import { getUnseenStartingLocations } from "../../common/scout.js";
+const SCOUT_MOVE_COOLDOWN_TICKS = 30;
+export class ScoutingSquad {
+    constructor() {
+        this.scoutingWith = null;
+    }
+    onAiUpdate(gameApi, actionsApi, playerData, squad, matchAwareness) {
+        const scoutNames = ["ADOG", "DOG", "E1", "E2", "FV", "HTK"];
+        const scouts = squad.getUnitsOfTypes(gameApi, ...scoutNames);
+        if ((matchAwareness.getSectorCache().getOverallVisibility() || 0) > 0.9) {
+            return disband();
+        }
+        if (scouts.length === 0) {
+            this.scoutingWith = null;
+            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);
+                    }
+                }
+            });
+            // Add a cooldown to scout attempts.
+            this.scoutingWith = {
+                unitId: scouts[0].id,
+                gameTick: gameApi.getCurrentTick(),
+            };
+        }
+        return noop();
+    }
+}

package/dist/bot/logic/squad/behaviours/squadExpansion.js

@@ -1,18 +1,31 @@
-import { SideType } from "@chronodivide/game-api";
+import { OrderType, SideType } from "@chronodivide/game-api";
+import { disband, noop, requestUnits } from "../squadBehaviour.js";
+const DEPLOY_COOLDOWN_TICKS = 30;
 // Expansion or initial base.
 export class SquadExpansion {
-    getDesiredComposition(gameApi, playerData, squad, threatData) {
-        // This squad desires an MCV.
-        let myMcvName = playerData.country?.side == SideType.GDI ? "AMCV" : "SMCV";
-        return [
-            {
-                unitName: myMcvName,
-                priority: 10,
-                amount: 1,
-            },
-        ];
+    constructor() {
+        this.hasAttemptedDeployWith = null;
     }
-    onAiUpdate(gameApi, playerData, squad, threatData) {
-        return {};
+    onAiUpdate(gameApi, actionsApi, playerData, squad, threatData) {
+        let myMcvName = playerData.country?.side == SideType.GDI ? "AMCV" : "SMCV";
+        const mcvs = squad.getUnitsOfType(gameApi, myMcvName);
+        if (mcvs.length === 0) {
+            // Perhaps we deployed already (or the unit was destroyed), end the mission.
+            if (this.hasAttemptedDeployWith !== null) {
+                return disband();
+            }
+            // We need an mcv!
+            return requestUnits(myMcvName, 100);
+        }
+        else if (!this.hasAttemptedDeployWith ||
+            gameApi.getCurrentTick() > this.hasAttemptedDeployWith.gameTick + DEPLOY_COOLDOWN_TICKS) {
+            actionsApi.orderUnits(mcvs.map((mcv) => mcv.id), OrderType.DeploySelected);
+            // Add a cooldown to deploy attempts.
+            this.hasAttemptedDeployWith = {
+                unitId: mcvs[0].id,
+                gameTick: gameApi.getCurrentTick(),
+            };
+        }
+        return noop();
     }
 }

package/dist/bot/logic/squad/squad.js

@@ -1,28 +1,78 @@
+import { disband } from "./squadBehaviour.js";
+import { getDistanceBetweenPoints } from "../map/map.js";
+import _ from "lodash";
 export var SquadLiveness;
 (function (SquadLiveness) {
     SquadLiveness[SquadLiveness["SquadDead"] = 0] = "SquadDead";
     SquadLiveness[SquadLiveness["SquadActive"] = 1] = "SquadActive";
 })(SquadLiveness || (SquadLiveness = {}));
+const calculateCenterOfMass = (unitTiles) => {
+    if (unitTiles.length === 0) {
+        return null;
+    }
+    // TODO: use median here
+    const sums = unitTiles.reduce(({ x, y }, tile) => {
+        return {
+            x: x + (tile?.rx || 0),
+            y: y + (tile?.ry || 0),
+        };
+    }, { x: 0, y: 0 });
+    const centerOfMass = {
+        x: Math.round(sums.x / unitTiles.length),
+        y: Math.round(sums.y / unitTiles.length),
+    };
+    // 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);
+    return { centerOfMass, maxDistance };
+};
 export class Squad {
-    constructor(name, behaviour, mission, unitIds = [], liveness = SquadLiveness.SquadActive, lastLivenessUpdateTick = 0) {
+    constructor(name, behaviour, mission, killable = false) {
         this.name = name;
         this.behaviour = behaviour;
         this.mission = mission;
-        this.unitIds = unitIds;
-        this.liveness = liveness;
-        this.lastLivenessUpdateTick = lastLivenessUpdateTick;
+        this.killable = killable;
+        this.unitIds = [];
+        this.liveness = SquadLiveness.SquadActive;
+        this.lastLivenessUpdateTick = 0;
+        this.centerOfMass = null;
+        this.maxDistanceToCenterOfMass = null;
     }
     getName() {
         return this.name;
     }
-    onAiUpdate(gameApi, playerData, threatData) {
+    getCenterOfMass() {
+        return this.centerOfMass;
+    }
+    getMaxDistanceToCenterOfMass() {
+        return this.maxDistanceToCenterOfMass;
+    }
+    onAiUpdate(gameApi, actionsApi, playerData, matchAwareness) {
         this.updateLiveness(gameApi);
+        const movableUnitTiles = this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => unit?.canMove)
+            .map((unit) => unit?.tile)
+            .filter((tile) => !!tile);
+        const tileMetrics = calculateCenterOfMass(movableUnitTiles);
+        if (tileMetrics) {
+            this.centerOfMass = tileMetrics.centerOfMass;
+            this.maxDistanceToCenterOfMass = tileMetrics.maxDistance;
+        }
+        else {
+            this.centerOfMass = null;
+            this.maxDistanceToCenterOfMass = null;
+        }
         if (this.mission && this.mission.isActive() == false) {
             // Orphaned squad, might get picked up later.
-            this.mission.removeSquad(this);
-            this.mission = undefined;
+            this.mission.removeSquad();
+            this.mission = null;
+            return disband();
         }
-        let outcome = this.behaviour.onAiUpdate(gameApi, playerData, this, threatData);
+        else if (!this.mission) {
+            return disband();
+        }
+        let outcome = this.behaviour.onAiUpdate(gameApi, actionsApi, playerData, this, matchAwareness);
         return outcome;
     }
     getMission() {
@@ -30,7 +80,7 @@ export class Squad {
     }
     setMission(mission) {
         if (this.mission != undefined && this.mission != mission) {
-            this.mission.removeSquad(this);
+            this.mission.removeSquad();
         }
         this.mission = mission;
     }
@@ -43,25 +93,28 @@ export class Squad {
             .filter((unit) => unit != null)
             .map((unit) => unit);
     }
-    getUnitsOfType(gameApi, f) {
+    getUnitsOfTypes(gameApi, ...names) {
         return this.unitIds
             .map((unitId) => gameApi.getUnitData(unitId))
-            .filter(f)
+            .filter((unit) => !!unit && names.includes(unit.name))
+            .map((unit) => unit);
+    }
+    getUnitsMatching(gameApi, filter) {
+        return this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => !!unit && filter(unit))
             .map((unit) => unit);
     }
     removeUnit(unitIdToRemove) {
         this.unitIds = this.unitIds.filter((unitId) => unitId != unitIdToRemove);
     }
-    clearUnits() {
-        this.unitIds = [];
-    }
     addUnit(unitIdToAdd) {
         this.unitIds.push(unitIdToAdd);
     }
     updateLiveness(gameApi) {
         this.unitIds = this.unitIds.filter((unitId) => gameApi.getUnitData(unitId));
         this.lastLivenessUpdateTick = gameApi.getCurrentTick();
-        if (this.unitIds.length == 0) {
+        if (this.killable && this.unitIds.length == 0) {
             if (this.liveness == SquadLiveness.SquadActive) {
                 this.liveness = SquadLiveness.SquadDead;
             }

package/dist/bot/logic/squad/squadBehaviour.js

@@ -1,5 +1,5 @@
-import { SquadExpansion } from "./behaviours/squadExpansion.js";
-export const allSquadBehaviours = [
-    //new SquadScouters(),
-    new SquadExpansion(),
-];
+export const noop = () => ({ type: "noop" });
+export const disband = () => ({ type: "disband" });
+export const requestUnits = (unitNames, priority) => ({ type: "request", unitNames, priority });
+export const requestSpecificUnits = (unitIds, priority) => ({ type: "requestSpecific", unitIds, priority });
+export const grabCombatants = (point, radius) => ({ type: "requestCombatants", point, radius });

package/dist/bot/logic/squad/squadBehaviours.js

@@ -0,0 +1,6 @@
+export {};
+/*
+export const ALL_SQUAD_BEHAVIOURS: SquadBehaviour[] = [
+    //new SquadScouters(),
+    new SquadExpansion(),
+];*/

package/dist/bot/logic/squad/squadController.js

@@ -1,43 +1,45 @@
 // Meta-controller for forming and controlling squads.
 import { SquadLiveness } from "./squad.js";
+import { getDistanceBetween } from "../map/map.js";
 export class SquadController {
-    constructor(squads = [], unitIdToSquad = new Map()) {
-        this.squads = squads;
-        this.unitIdToSquad = unitIdToSquad;
+    constructor() {
+        this.squads = [];
+        this.unitIdToSquad = new Map();
     }
-    onAiUpdate(gameApi, playerData, threatData) {
-        // Remove dead squads.
-        this.squads = this.squads.filter((squad) => squad.getLiveness() == SquadLiveness.SquadDead);
+    onAiUpdate(gameApi, actionsApi, playerData, matchAwareness, logger) {
+        // Remove dead squads or those where the mission is dead.
+        this.squads = this.squads.filter((squad) => squad.getLiveness() !== SquadLiveness.SquadDead);
         this.squads.sort((a, b) => a.getName().localeCompare(b.getName()));
         // Check for units in multiple squads, this shouldn't happen.
         this.unitIdToSquad = new Map();
         this.squads.forEach((squad) => {
             squad.getUnitIds().forEach((unitId) => {
                 if (this.unitIdToSquad.has(unitId)) {
-                    console.log(`WARNING: unit ${unitId} is in multiple squads, please debug.`);
+                    logger(`WARNING: unit ${unitId} is in multiple squads, please debug.`);
                 }
                 else {
                     this.unitIdToSquad.set(unitId, squad);
                 }
             });
         });
-        let squadActions = this.squads.map((squad) => {
+        const squadActions = this.squads.map((squad) => {
             return {
                 squad,
-                action: squad.onAiUpdate(gameApi, playerData, threatData),
+                action: squad.onAiUpdate(gameApi, actionsApi, playerData, matchAwareness),
             };
         });
         // Handle disbands and merges.
-        const isDisband = (a) => a.type == "disband";
-        const isMerge = (a) => a.type == "mergeInto";
+        const isDisband = (a) => a.type === "disband";
+        const isMerge = (a) => a.type === "mergeInto";
         let disbandedSquads = new Set();
         squadActions
             .filter((a) => isDisband(a.action))
             .forEach((a) => {
+            logger(`Squad ${a.squad.getName()} disbanding as requested.`);
+            a.squad.getMission()?.removeSquad();
             a.squad.getUnitIds().forEach((unitId) => {
                 this.unitIdToSquad.delete(unitId);
             });
-            a.squad.clearUnits();
             disbandedSquads.add(a.squad.getName());
         });
         squadActions
@@ -45,14 +47,103 @@ export class SquadController {
             .forEach((a) => {
             let mergeInto = a.action;
             if (disbandedSquads.has(mergeInto.mergeInto.getName())) {
-                console.log("Merging into a disbanded squad, cancelling.");
+                logger(`Squad ${a.squad.getName()} tried to merge into disbanded squad ${mergeInto.mergeInto.getName()}, cancelling.`);
                 return;
             }
             a.squad.getUnitIds().forEach((unitId) => mergeInto.mergeInto.addUnit(unitId));
             disbandedSquads.add(a.squad.getName());
         });
         // remove disbanded and merged squads.
-        this.squads.filter((squad) => !disbandedSquads.has(squad.getName()));
-        // Form squads.
+        this.squads = this.squads.filter((squad) => !disbandedSquads.has(squad.getName()));
+        // Request specific units by ID
+        const isRequestSpecific = (a) => a.type === "requestSpecific";
+        const unitIdToHighestRequest = squadActions
+            .filter((a) => isRequestSpecific(a.action))
+            .reduce((prev, a) => {
+            const squadWithAction = a;
+            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;
+                }
+            });
+            return prev;
+        }, {});
+        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);
+            }
+        });
+        // Request units by type
+        const isRequest = (a) => a.type === "request";
+        const unitTypeToHighestRequest = squadActions
+            .filter((a) => isRequest(a.action))
+            .reduce((prev, a) => {
+            const squadWithAction = a;
+            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;
+                }
+            });
+            return prev;
+        }, {});
+        // Request combat-capable units in an area
+        const isGrab = (a) => a.type === "requestCombatants";
+        const grabRequests = squadActions.filter((a) => isGrab(a.action));
+        // Find loose units
+        const unitIds = gameApi.getVisibleUnits(playerData.name, "self");
+        const freeUnits = unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .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}`);
+                        this.addUnitToSquad(requestingSquad, freeUnit);
+                        return true;
+                    }
+                    else {
+                        return false;
+                    }
+                });
+            }
+        });
+    }
+    addUnitToSquad(squad, unit) {
+        squad.addUnit(unit.id);
+        this.unitIdToSquad.set(unit.id, squad);
+    }
+    registerSquad(squad) {
+        this.squads.push(squad);
     }
 }