@supalosa/chronodivide-bot 0.1.0

package/dist/bot/logic/building/queueController.js

@@ -0,0 +1,168 @@
+import { QueueStatus, QueueType, } from "@chronodivide/game-api";
+import { BUILDING_NAME_TO_RULES, DEFAULT_BUILDING_PRIORITY, getDefaultPlacementLocation, } from "./building.js";
+export const QUEUES = [
+    QueueType.Structures,
+    QueueType.Armory,
+    QueueType.Infantry,
+    QueueType.Vehicles,
+    QueueType.Aircrafts,
+    QueueType.Ships,
+];
+export const queueTypeToName = (queue) => {
+    switch (queue) {
+        case QueueType.Structures:
+            return "Structures";
+        case QueueType.Armory:
+            return "Armory";
+        case QueueType.Infantry:
+            return "Infantry";
+        case QueueType.Vehicles:
+            return "Vehicles";
+        case QueueType.Aircrafts:
+            return "Aircrafts";
+        case QueueType.Ships:
+            return "Ships";
+        default:
+            return "Unknown";
+    }
+};
+// Repair buildings at this ratio of the maxHitpoints.
+const REPAIR_HITPOINTS_RATIO = 0.9;
+// Don't repair buildings more often than this.
+const REPAIR_COOLDOWN_TICKS = 15;
+const DEBUG_BUILD_QUEUES = true;
+export class QueueController {
+    constructor(buildingIdToLastHitpoints = new Map(), buildingIdLastRepairedAtTick = new Map()) {
+        this.buildingIdToLastHitpoints = buildingIdToLastHitpoints;
+        this.buildingIdLastRepairedAtTick = buildingIdLastRepairedAtTick;
+    }
+    onAiUpdate(game, productionApi, actionsApi, playerData, threatCache, logger) {
+        const decisions = QUEUES.map((queueType) => {
+            const options = productionApi.getAvailableObjects(queueType);
+            return {
+                queue: queueType,
+                decision: this.getBestOptionForBuilding(game, options, threatCache, playerData, logger),
+            };
+        }).filter((decision) => decision.decision != null);
+        let totalWeightAcrossQueues = decisions
+            .map((decision) => decision.decision?.priority)
+            .reduce((pV, cV) => pV + cV, 0);
+        let totalCostAcrossQueues = decisions
+            .map((decision) => decision.decision?.unit.cost)
+            .reduce((pV, cV) => pV + cV, 0);
+        decisions.forEach((decision) => {
+            this.updateBuildQueue(game, productionApi, actionsApi, playerData, threatCache, decision.queue, decision.decision, totalWeightAcrossQueues, totalCostAcrossQueues, logger);
+        });
+        // Repair is simple - just repair everything that's damaged.
+        // Unfortunately there doesn't seem to be an API to determine if something is being repaired, so we have to remember it.
+        game.getVisibleUnits(playerData.name, "self", (r) => r.repairable).forEach((unitId) => {
+            const unit = game.getUnitData(unitId);
+            if (!unit || !unit.hitPoints || !unit.maxHitPoints) {
+                return;
+            }
+            const lastKnownHitpoints = this.buildingIdToLastHitpoints.get(unitId) || unit.hitPoints;
+            const buildingLastRepairedAt = this.buildingIdLastRepairedAtTick.get(unitId) || 0;
+            // Only repair if HP is going down and if we haven't recently repaired it
+            if (unit.hitPoints <= lastKnownHitpoints &&
+                game.getCurrentTick() > buildingLastRepairedAt + REPAIR_COOLDOWN_TICKS &&
+                unit.hitPoints < unit.maxHitPoints * REPAIR_HITPOINTS_RATIO) {
+                actionsApi.toggleRepairWrench(unitId);
+                this.buildingIdLastRepairedAtTick.set(unitId, game.getCurrentTick());
+            }
+            this.buildingIdToLastHitpoints.set(unitId, unit.hitPoints);
+        });
+    }
+    updateBuildQueue(game, productionApi, actionsApi, playerData, threatCache, queueType, decision, totalWeightAcrossQueues, totalCostAcrossQueues, logger) {
+        const myCredits = playerData.credits;
+        let queueData = productionApi.getQueueData(queueType);
+        if (queueData.status == QueueStatus.Idle) {
+            // Start building the decided item.
+            if (decision !== undefined) {
+                logger(`Decision (${queueTypeToName(queueType)}): ${decision.unit.name}`);
+                actionsApi.queueForProduction(queueType, decision.unit.name, decision.unit.type, 1);
+            }
+        }
+        else if (queueData.status == QueueStatus.Ready && queueData.items.length > 0) {
+            // Consider placing it.
+            const objectReady = queueData.items[0].rules;
+            if (queueType == QueueType.Structures || queueType == QueueType.Armory) {
+                logger(`Complete ${queueTypeToName(queueType)}: ${objectReady.name}`);
+                let location = this.getBestLocationForStructure(game, playerData, objectReady);
+                if (location !== undefined) {
+                    actionsApi.placeBuilding(objectReady.name, location.rx, location.ry);
+                }
+            }
+        }
+        else if (queueData.status == QueueStatus.Active && queueData.items.length > 0 && decision != null) {
+            // Consider cancelling if something else is significantly higher priority.
+            const current = queueData.items[0].rules;
+            const options = productionApi.getAvailableObjects(queueType);
+            if (decision.unit != current) {
+                // Changing our mind.
+                let currentItemPriority = this.getPriorityForBuildingOption(current, game, playerData, threatCache);
+                let newItemPriority = decision.priority;
+                if (newItemPriority > currentItemPriority * 2) {
+                    logger(`Dequeueing queue ${queueTypeToName(queueData.type)} unit ${current.name} because ${decision.unit.name} has 2x higher priority.`);
+                    actionsApi.unqueueFromProduction(queueData.type, current.name, current.type, 1);
+                }
+            }
+            else {
+                // Not changing our mind, but maybe other queues are more important for now.
+                if (totalCostAcrossQueues > myCredits && decision.priority < totalWeightAcrossQueues * 0.25) {
+                    logger(`Pausing queue ${queueTypeToName(queueData.type)} because weight is low (${decision.priority}/${totalWeightAcrossQueues})`);
+                    actionsApi.pauseProduction(queueData.type);
+                }
+            }
+        }
+        else if (queueData.status == QueueStatus.OnHold) {
+            // Consider resuming queue if priority is high relative to other queues.
+            if (myCredits >= totalCostAcrossQueues) {
+                logger(`Resuming queue ${queueTypeToName(queueData.type)} because credits are high`);
+                actionsApi.resumeProduction(queueData.type);
+            }
+            else if (decision && decision.priority >= totalWeightAcrossQueues * 0.25) {
+                logger(`Resuming queue ${queueTypeToName(queueData.type)} because weight is high (${decision.priority}/${totalWeightAcrossQueues})`);
+                actionsApi.resumeProduction(queueData.type);
+            }
+        }
+    }
+    getBestOptionForBuilding(game, options, threatCache, playerData, logger) {
+        let priorityQueue = [];
+        options.forEach((option) => {
+            let priority = this.getPriorityForBuildingOption(option, game, playerData, threatCache);
+            if (priority > 0) {
+                priorityQueue.push({ unit: option, priority: priority });
+            }
+        });
+        priorityQueue = priorityQueue.sort((a, b) => {
+            return a.priority - b.priority;
+        });
+        if (priorityQueue.length > 0) {
+            if (DEBUG_BUILD_QUEUES && game.getCurrentTick() % 100 === 0) {
+                let queueString = priorityQueue.map((item) => item.unit.name + "(" + item.priority + ")").join(", ");
+                logger(`Build priority currently: ${queueString}`);
+            }
+        }
+        return priorityQueue.pop();
+    }
+    getPriorityForBuildingOption(option, game, playerStatus, threatCache) {
+        if (BUILDING_NAME_TO_RULES.has(option.name)) {
+            let logic = BUILDING_NAME_TO_RULES.get(option.name);
+            return logic.getPriority(game, playerStatus, option, threatCache);
+        }
+        else {
+            // Fallback priority when there are no rules.
+            return (DEFAULT_BUILDING_PRIORITY - game.getVisibleUnits(playerStatus.name, "self", (r) => r == option).length);
+        }
+    }
+    getBestLocationForStructure(game, playerData, objectReady) {
+        if (BUILDING_NAME_TO_RULES.has(objectReady.name)) {
+            let logic = BUILDING_NAME_TO_RULES.get(objectReady.name);
+            return logic.getPlacementLocation(game, playerData, objectReady);
+        }
+        else {
+            // fallback placement logic
+            return getDefaultPlacementLocation(game, playerData, playerData.startLocation, objectReady);
+        }
+    }
+}

package/dist/bot/logic/building/queues.js

@@ -0,0 +1,19 @@
+import { QueueType } from "@chronodivide/game-api";
+export const queueTypeToName = (queue) => {
+    switch (queue) {
+        case QueueType.Structures:
+            return "Structures";
+        case QueueType.Armory:
+            return "Armory";
+        case QueueType.Infantry:
+            return "Infantry";
+        case QueueType.Vehicles:
+            return "Vehicles";
+        case QueueType.Aircrafts:
+            return "Aircrafts";
+        case QueueType.Ships:
+            return "Ships";
+        default:
+            return "Unknown";
+    }
+};

package/dist/bot/logic/building/resourceCollectionBuilding.js

@@ -0,0 +1,34 @@
+import { BasicBuilding } from "./basicBuilding.js";
+import { getDefaultPlacementLocation, } from "./building.js";
+export class ResourceCollectionBuilding extends BasicBuilding {
+    constructor(basePriority, maxNeeded, onlyBuildWhenFloatingCreditsAmount) {
+        super(basePriority, maxNeeded, onlyBuildWhenFloatingCreditsAmount);
+    }
+    getPlacementLocation(game, playerData, technoRules) {
+        // Prefer spawning close to ore.
+        let selectedLocation = playerData.startLocation;
+        var closeOre;
+        var closeOreDist;
+        let allTileResourceData = game.mapApi.getAllTilesResourceData();
+        for (let i = 0; i < allTileResourceData.length; ++i) {
+            let tileResourceData = allTileResourceData[i];
+            if (tileResourceData.spawnsOre) {
+                let dist = Math.sqrt((selectedLocation.x - tileResourceData.tile.rx) ** 2 +
+                    (selectedLocation.y - tileResourceData.tile.ry) ** 2);
+                if (closeOreDist == undefined || dist < closeOreDist) {
+                    closeOreDist = dist;
+                    closeOre = tileResourceData.tile;
+                }
+            }
+        }
+        if (closeOre) {
+            selectedLocation = { x: closeOre.rx, y: closeOre.ry };
+        }
+        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules);
+    }
+    // Don't build/start selling these if we don't have any harvesters
+    getMaxCount(game, playerData, technoRules, threatCache) {
+        const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
+        return Math.max(1, harvesters * 2);
+    }
+}

package/dist/bot/logic/map/map.js

@@ -0,0 +1,57 @@
+// Expensive one-time call to determine the size of the map.
+// The result is a point just outside the bounds of the map.
+export function determineMapBounds(mapApi) {
+    // TODO Binary Search this.
+    // Start from the last spawn positions to save time.
+    let maxX = 0;
+    let maxY = 0;
+    mapApi.getStartingLocations().forEach((point) => {
+        if (point.x > maxX) {
+            maxX = point.x;
+        }
+        if (point.y > maxY) {
+            maxY = point.y;
+        }
+    });
+    // Expand outwards until we find the bounds.
+    for (let testX = maxX; testX < 10000; ++testX) {
+        if (mapApi.getTile(testX, 0) == undefined) {
+            maxX = testX;
+            break;
+        }
+    }
+    for (let testY = maxY; testY < 10000; ++testY) {
+        if (mapApi.getTile(testY, 0) == undefined) {
+            maxY = testY;
+            break;
+        }
+    }
+    return { x: maxX, y: maxY };
+}
+export function calculateAreaVisibility(mapApi, playerData, startPoint, endPoint) {
+    let validTiles = 0, visibleTiles = 0;
+    for (let xx = startPoint.x; xx < endPoint.x; ++xx) {
+        for (let yy = startPoint.y; yy < endPoint.y; ++yy) {
+            let tile = mapApi.getTile(xx, yy);
+            if (tile) {
+                ++validTiles;
+                if (mapApi.isVisibleTile(tile, playerData.name)) {
+                    ++visibleTiles;
+                }
+            }
+        }
+    }
+    let result = { visibleTiles, validTiles };
+    return result;
+}
+export function getPointTowardsOtherPoint(gameApi, startLocation, endLocation, minRadius, maxRadius, randomAngle) {
+    let radius = minRadius + Math.round(gameApi.generateRandom() * (maxRadius - minRadius));
+    let directionToSpawn = Math.atan2(endLocation.y - startLocation.y, endLocation.x - startLocation.x);
+    let randomisedDirection = directionToSpawn - (randomAngle * (Math.PI / 12) + 2 * randomAngle * gameApi.generateRandom() * (Math.PI / 12));
+    let candidatePointX = Math.round(startLocation.x + Math.cos(randomisedDirection) * radius);
+    let candidatePointY = Math.round(startLocation.y + Math.sin(randomisedDirection) * radius);
+    return { x: candidatePointX, y: candidatePointY };
+}
+export function getDistanceBetweenPoints(startLocation, endLocation) {
+    return Math.sqrt((startLocation.x - endLocation.x) ** 2 + (startLocation.y - endLocation.y) ** 2);
+}

package/dist/bot/logic/map/sector.js

@@ -0,0 +1,104 @@
+// A sector is a uniform-sized segment of the map.
+import { calculateAreaVisibility } from "./map.js";
+export const SECTOR_SIZE = 8;
+export class Sector {
+    constructor(sectorStartPoint, sectorStartTile, sectorVisibilityPct, sectorVisibilityLastCheckTick) {
+        this.sectorStartPoint = sectorStartPoint;
+        this.sectorStartTile = sectorStartTile;
+        this.sectorVisibilityPct = sectorVisibilityPct;
+        this.sectorVisibilityLastCheckTick = sectorVisibilityLastCheckTick;
+    }
+}
+export class SectorCache {
+    constructor(mapApi, mapBounds) {
+        this.sectors = [];
+        this.mapBounds = mapBounds;
+        this.sectorsX = Math.ceil(mapBounds.x / SECTOR_SIZE);
+        this.sectorsY = Math.ceil(mapBounds.y / SECTOR_SIZE);
+        this.sectors = new Array(this.sectorsX);
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            this.sectors[xx] = new Array(this.sectorsY);
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                this.sectors[xx][yy] = new Sector({ x: xx * SECTOR_SIZE, y: yy * SECTOR_SIZE }, mapApi.getTile(xx * SECTOR_SIZE, yy * SECTOR_SIZE), undefined, undefined);
+            }
+        }
+    }
+    updateSectors(currentGameTick, maxSectorsToUpdate, mapApi, playerData) {
+        let nextSectorX = this.lastUpdatedSectorX ? this.lastUpdatedSectorX + 1 : 0;
+        let nextSectorY = this.lastUpdatedSectorY ? this.lastUpdatedSectorY : 0;
+        let updatedThisCycle = 0;
+        while (updatedThisCycle < maxSectorsToUpdate) {
+            if (nextSectorX >= this.sectorsX) {
+                nextSectorX = 0;
+                ++nextSectorY;
+            }
+            if (nextSectorY >= this.sectorsY) {
+                nextSectorY = 0;
+                nextSectorX = 0;
+            }
+            let sector = this.getSector(nextSectorX, nextSectorY);
+            if (sector) {
+                sector.sectorVisibilityLastCheckTick = currentGameTick;
+                let sp = sector.sectorStartPoint;
+                let ep = {
+                    x: sector.sectorStartPoint.x + SECTOR_SIZE,
+                    y: sector.sectorStartPoint.y + SECTOR_SIZE,
+                };
+                let visibility = calculateAreaVisibility(mapApi, playerData, sp, ep);
+                if (visibility.validTiles > 0) {
+                    sector.sectorVisibilityPct = visibility.visibleTiles / visibility.validTiles;
+                }
+                else {
+                    sector.sectorVisibilityPct = undefined;
+                }
+            }
+            this.lastUpdatedSectorX = nextSectorX;
+            this.lastUpdatedSectorY = nextSectorY;
+            ++nextSectorX;
+            ++updatedThisCycle;
+        }
+    }
+    // Return % of sectors that are updated.
+    getSectorUpdateRatio(sectorsUpdatedSinceGameTick) {
+        let updated = 0, total = 0;
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                let sector = this.sectors[xx][yy];
+                if (sector &&
+                    sector.sectorVisibilityLastCheckTick &&
+                    sector.sectorVisibilityLastCheckTick >= sectorsUpdatedSinceGameTick) {
+                    ++updated;
+                }
+                ++total;
+            }
+        }
+        return updated / total;
+    }
+    // Return % of tiles that are visible. Returns undefined if we haven't scanned the whole map yet.
+    getOverallVisibility() {
+        let visible = 0, total = 0;
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                let sector = this.sectors[xx][yy];
+                // Undefined visibility.
+                if (sector.sectorVisibilityPct != undefined) {
+                    visible += sector.sectorVisibilityPct;
+                    total += 1.0;
+                }
+            }
+        }
+        return visible / total;
+    }
+    getSector(sectorX, sectorY) {
+        if (sectorX < 0 || sectorX >= this.sectorsX || sectorY < 0 || sectorY >= this.sectorsY) {
+            return undefined;
+        }
+        return this.sectors[sectorX][sectorY];
+    }
+    getSectorForWorldPosition(x, y) {
+        if (x < 0 || x >= this.mapBounds.x || y < 0 || y >= this.mapBounds.y) {
+            return undefined;
+        }
+        return this.sectors[Math.floor(x / SECTOR_SIZE)][Math.floor(y / SECTOR_SIZE)];
+    }
+}

package/dist/bot/logic/mission/basicMission.js

@@ -0,0 +1,30 @@
+// A basic mission requests specific units and does nothing with them. It is not recommended
+// to actually create this in a game as they'll just sit around idle.
+export class BasicMission {
+    constructor(uniqueName, priority = 1, squads = []) {
+        this.uniqueName = uniqueName;
+        this.priority = priority;
+        this.squads = squads;
+    }
+    getUniqueName() {
+        return this.uniqueName;
+    }
+    isActive() {
+        return true;
+    }
+    removeSquad(squad) {
+        this.squads = this.squads.filter((s) => s != squad);
+    }
+    addSquad(squad) {
+        if (!this.squads.find((s) => s == squad)) {
+            this.squads.push(squad);
+        }
+    }
+    getSquads() {
+        return this.squads;
+    }
+    onAiUpdate(gameApi, playerData, threatData) {
+        return {};
+    }
+    onSquadAdded(gameApi, playerData, threatData) { }
+}

package/dist/bot/logic/mission/expansionMission.js

@@ -0,0 +1,14 @@
+import { BasicMission } from "./basicMission.js";
+export class ExpansionMission extends BasicMission {
+    constructor(uniqueName, priority) {
+        super(uniqueName, priority);
+    }
+    onAiUpdate(gameApi, playerData, threatData) {
+        return {};
+    }
+}
+export class ExpansionMissionFactory {
+    maybeCreateMission(gameApi, playerData, threatData, existingMissions) {
+        return new ExpansionMission("expansion", 10);
+    }
+}

package/dist/bot/logic/mission/mission.js

@@ -0,0 +1,2 @@
+import { ExpansionMissionFactory } from "./expansionMission.js";
+export const missionFactories = [new ExpansionMissionFactory()];

package/dist/bot/logic/mission/missionController.js

@@ -0,0 +1,47 @@
+// Meta-controller for forming and controlling squads.
+import { missionFactories } from "./mission.js";
+export class MissionController {
+    constructor(missions = []) {
+        this.missions = missions;
+    }
+    onAiUpdate(gameApi, playerData, threatData) {
+        // Remove disbanded missions.
+        this.missions = this.missions.filter((missions) => missions.isActive());
+        let missionActions = this.missions.map((mission) => {
+            return {
+                mission,
+                action: mission.onAiUpdate(gameApi, playerData, threatData),
+            };
+        });
+        // Handle disbands and merges.
+        const isDisband = (a) => a.type == "disband";
+        let disbandedMissions = new Set();
+        missionActions
+            .filter((a) => isDisband(a.action))
+            .forEach((a) => {
+            a.mission.getSquads().forEach((squad) => {
+                squad.setMission(undefined);
+            });
+            disbandedMissions.add(a.mission.getUniqueName());
+        });
+        // remove disbanded and merged squads.
+        this.missions.filter((missions) => !disbandedMissions.has(missions.getUniqueName()));
+        // Create missions.
+        let newMissions;
+        let missionNames = new Set();
+        this.missions.forEach((mission) => missionNames.add(mission.getUniqueName()));
+        missionFactories.forEach((missionFactory) => {
+            let maybeMission = missionFactory.maybeCreateMission(gameApi, playerData, threatData, this.missions);
+            if (maybeMission) {
+                if (missionNames.has(maybeMission.getUniqueName())) {
+                    //console.log(`Rejecting new mission ${maybeMission.getUniqueName()} as another mission exists.`);
+                }
+                else {
+                    console.log(`Starting new mission ${maybeMission.getUniqueName()}.`);
+                    this.missions.push(maybeMission);
+                    missionNames.add(maybeMission.getUniqueName());
+                }
+            }
+        });
+    }
+}

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

@@ -0,0 +1,18 @@
+import { SideType } from "@chronodivide/game-api";
+// 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,
+            },
+        ];
+    }
+    onAiUpdate(gameApi, playerData, squad, threatData) {
+        return {};
+    }
+}

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

@@ -0,0 +1,8 @@
+export class SquadScouters {
+    requestConstruction(gameApi, playerData, squad, threatData) {
+        return [];
+    }
+    onAiUpdate(gameApi, playerData, squad, threatData) {
+        return {};
+    }
+}

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

@@ -0,0 +1,73 @@
+export var SquadLiveness;
+(function (SquadLiveness) {
+    SquadLiveness[SquadLiveness["SquadDead"] = 0] = "SquadDead";
+    SquadLiveness[SquadLiveness["SquadActive"] = 1] = "SquadActive";
+})(SquadLiveness || (SquadLiveness = {}));
+export class Squad {
+    constructor(name, behaviour, mission, unitIds = [], liveness = SquadLiveness.SquadActive, lastLivenessUpdateTick = 0) {
+        this.name = name;
+        this.behaviour = behaviour;
+        this.mission = mission;
+        this.unitIds = unitIds;
+        this.liveness = liveness;
+        this.lastLivenessUpdateTick = lastLivenessUpdateTick;
+    }
+    getName() {
+        return this.name;
+    }
+    onAiUpdate(gameApi, playerData, threatData) {
+        this.updateLiveness(gameApi);
+        if (this.mission && this.mission.isActive() == false) {
+            // Orphaned squad, might get picked up later.
+            this.mission.removeSquad(this);
+            this.mission = undefined;
+        }
+        let outcome = this.behaviour.onAiUpdate(gameApi, playerData, this, threatData);
+        return outcome;
+    }
+    getMission() {
+        return this.mission;
+    }
+    setMission(mission) {
+        if (this.mission != undefined && this.mission != mission) {
+            this.mission.removeSquad(this);
+        }
+        this.mission = mission;
+    }
+    getUnitIds() {
+        return this.unitIds;
+    }
+    getUnits(gameApi) {
+        return this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => unit != null)
+            .map((unit) => unit);
+    }
+    getUnitsOfType(gameApi, f) {
+        return this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter(f)
+            .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.liveness == SquadLiveness.SquadActive) {
+                this.liveness = SquadLiveness.SquadDead;
+            }
+        }
+    }
+    getLiveness() {
+        return this.liveness;
+    }
+}

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

@@ -0,0 +1,5 @@
+import { SquadExpansion } from "./behaviours/squadExpansion.js";
+export const allSquadBehaviours = [
+    //new SquadScouters(),
+    new SquadExpansion(),
+];

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

@@ -0,0 +1,58 @@
+// Meta-controller for forming and controlling squads.
+import { SquadLiveness } from "./squad.js";
+export class SquadController {
+    constructor(squads = [], unitIdToSquad = new Map()) {
+        this.squads = squads;
+        this.unitIdToSquad = unitIdToSquad;
+    }
+    onAiUpdate(gameApi, playerData, threatData) {
+        // Remove dead squads.
+        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.`);
+                }
+                else {
+                    this.unitIdToSquad.set(unitId, squad);
+                }
+            });
+        });
+        let squadActions = this.squads.map((squad) => {
+            return {
+                squad,
+                action: squad.onAiUpdate(gameApi, playerData, threatData),
+            };
+        });
+        // Handle disbands and merges.
+        const isDisband = (a) => a.type == "disband";
+        const isMerge = (a) => a.type == "mergeInto";
+        let disbandedSquads = new Set();
+        squadActions
+            .filter((a) => isDisband(a.action))
+            .forEach((a) => {
+            a.squad.getUnitIds().forEach((unitId) => {
+                this.unitIdToSquad.delete(unitId);
+            });
+            a.squad.clearUnits();
+            disbandedSquads.add(a.squad.getName());
+        });
+        squadActions
+            .filter((a) => isMerge(a.action))
+            .forEach((a) => {
+            let mergeInto = a.action;
+            if (disbandedSquads.has(mergeInto.mergeInto.getName())) {
+                console.log("Merging into a disbanded squad, 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.
+    }
+}

package/dist/bot/logic/threat/threat.js

@@ -0,0 +1,22 @@
+// A periodically-refreshed cache of known threats to a bot so we can use it in decision making.
+export class GlobalThreat {
+    constructor(certainty, // 0.0 - 1.0 based on approximate visibility around the map.
+    totalOffensiveLandThreat, // a number that approximates how much land-based firepower our opponents have.
+    totalOffensiveAirThreat, // a number that approximates how much airborne firepower our opponents have.
+    totalOffensiveAntiAirThreat, // a number that approximates how much anti-air firepower our opponents have.
+    totalDefensiveThreat, // a number that approximates how much defensive power our opponents have.
+    totalDefensivePower, // a number that approximates how much defensive power we have.
+    totalAvailableAntiGroundFirepower, // how much anti-ground power we have
+    totalAvailableAntiAirFirepower, // how much anti-air power we have
+    totalAvailableAirPower) {
+        this.certainty = certainty;
+        this.totalOffensiveLandThreat = totalOffensiveLandThreat;
+        this.totalOffensiveAirThreat = totalOffensiveAirThreat;
+        this.totalOffensiveAntiAirThreat = totalOffensiveAntiAirThreat;
+        this.totalDefensiveThreat = totalDefensiveThreat;
+        this.totalDefensivePower = totalDefensivePower;
+        this.totalAvailableAntiGroundFirepower = totalAvailableAntiGroundFirepower;
+        this.totalAvailableAntiAirFirepower = totalAvailableAntiAirFirepower;
+        this.totalAvailableAirPower = totalAvailableAirPower;
+    }
+}