@supalosa/chronodivide-bot 0.1.1 → 0.2.1

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

@@ -0,0 +1,82 @@
+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 = 30;
+// 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;
+const GATHER_RATIO = 10;
+var SquadState;
+(function (SquadState) {
+    SquadState[SquadState["Gathering"] = 0] = "Gathering";
+    SquadState[SquadState["Attacking"] = 1] = "Attacking";
+})(SquadState || (SquadState = {}));
+export class AttackOrDefenceSquad {
+    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);
+            if (this.state === SquadState.Gathering) {
+                // 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));
+                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;
+                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(this.rallyArea, this.radius * GRAB_RADIUS);
+        }
+        else {
+            return noop();
+        }
+    }
+}

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,39 @@
+import { AttackState, ObjectType, OrderType, StanceType } from "@chronodivide/game-api";
+import { getDistanceBetweenUnits } from "../../map/map.js";
+// Micro methods
+export function manageMoveMicro(actionsApi, attacker, attackPoint) {
+    if (attacker.name === "E1") {
+        const isDeployed = attacker.stance === StanceType.Deployed;
+        if (isDeployed) {
+            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;
+        const isDeployed = attacker.stance === StanceType.Deployed;
+        if (!isDeployed && (distance <= deployedWeaponRange || attacker.attackState === AttackState.JustFired)) {
+            actionsApi.orderUnits([attacker.id], OrderType.DeploySelected);
+            return;
+        }
+        else if (isDeployed && 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,27 @@
+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.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.
+            actionsApi.orderUnits(squad.getUnitIds(), OrderType.AttackMove, this.retreatToPoint.x, this.retreatToPoint.y);
+            return disband();
+        }
+        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, 1000);
+        }
+    }
+}

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(),
+];*/