@supalosa/chronodivide-bot 0.1.0

package/src/bot/logic/map/sector.ts

@@ -0,0 +1,130 @@
+// A sector is a uniform-sized segment of the map.
+
+import { MapApi, PlayerData, Point2D, Tile } from "@chronodivide/game-api";
+import { calculateAreaVisibility } from "./map.js";
+
+export const SECTOR_SIZE = 8;
+
+export class Sector {
+    constructor(
+        public sectorStartPoint: Point2D,
+        public sectorStartTile: Tile | undefined,
+        public sectorVisibilityPct: number | undefined,
+        public sectorVisibilityLastCheckTick: number | undefined,
+    ) {}
+}
+
+export class SectorCache {
+    private sectors: Sector[][] = [];
+    private mapBounds: Point2D;
+    private sectorsX: number;
+    private sectorsY: number;
+    private lastUpdatedSectorX: number | undefined;
+    private lastUpdatedSectorY: number | undefined;
+
+    constructor(mapApi: MapApi, mapBounds: Point2D) {
+        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,
+                );
+            }
+        }
+    }
+
+    public updateSectors(currentGameTick: number, maxSectorsToUpdate: number, mapApi: MapApi, playerData: 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: Sector | undefined = 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.
+    public getSectorUpdateRatio(sectorsUpdatedSinceGameTick: number): number {
+        let updated = 0,
+            total = 0;
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                let sector: 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.
+    public getOverallVisibility(): number | undefined {
+        let visible = 0,
+            total = 0;
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                let sector: Sector = this.sectors[xx][yy];
+
+                // Undefined visibility.
+                if (sector.sectorVisibilityPct != undefined) {
+                    visible += sector.sectorVisibilityPct;
+                    total += 1.0;
+                }
+            }
+        }
+        return visible / total;
+    }
+
+    public getSector(sectorX: number, sectorY: number): Sector | undefined {
+        if (sectorX < 0 || sectorX >= this.sectorsX || sectorY < 0 || sectorY >= this.sectorsY) {
+            return undefined;
+        }
+        return this.sectors[sectorX][sectorY];
+    }
+
+    public getSectorForWorldPosition(x: number, y: number): Sector | undefined {
+        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/src/bot/logic/mission/basicMission.ts

@@ -0,0 +1,42 @@
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { Squad } from "../squad/squad.js";
+import { GlobalThreat } from "../threat/threat.js";
+import { Mission, MissionAction, MissionActionNoop, MissionFactory } from "./mission.js";
+
+// 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 implements Mission {
+    constructor(
+        private uniqueName: string,
+        private priority: number = 1,
+        private squads: Squad[] = [],
+    ) {}
+
+    getUniqueName(): string {
+        return this.uniqueName;
+    }
+
+    isActive(): boolean {
+        return true;
+    }
+
+    removeSquad(squad: Squad): void {
+        this.squads = this.squads.filter((s) => s != squad);
+    }
+
+    addSquad(squad: Squad): void {
+        if (!this.squads.find((s) => s == squad)) {
+            this.squads.push(squad);
+        }
+    }
+
+    getSquads(): Squad[] {
+        return this.squads;
+    }
+
+    onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat): MissionAction {
+        return {} as MissionActionNoop;
+    }
+
+    onSquadAdded(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat): void {}
+}

package/src/bot/logic/mission/expansionMission.ts

@@ -0,0 +1,25 @@
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { BasicMission } from "./basicMission.js";
+import { Mission, MissionAction, MissionActionNoop, MissionFactory } from "./mission";
+
+export class ExpansionMission extends BasicMission {
+    constructor(uniqueName: string, priority: number) {
+        super(uniqueName, priority);
+    }
+
+    onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat): MissionAction {
+        return {} as MissionActionNoop;
+    }
+}
+
+export class ExpansionMissionFactory implements MissionFactory {
+    maybeCreateMission(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        threatData: GlobalThreat | undefined,
+        existingMissions: Mission[],
+    ): Mission | undefined {
+        return new ExpansionMission("expansion", 10);
+    }
+}

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

@@ -0,0 +1,47 @@
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { Squad } from "../squad/squad.js";
+import { SquadBehaviour } from "../squad/squadBehaviour.js";
+import { GlobalThreat } from "../threat/threat.js";
+import { ExpansionMissionFactory } from "./expansionMission.js";
+
+// AI starts Missions based on heuristics, which have one or more squads.
+// Missions can create squads (but squads will disband themselves).
+export interface Mission {
+    onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat | undefined): MissionAction;
+
+    isActive(): boolean;
+
+    removeSquad(squad: Squad): void;
+
+    addSquad(squad: Squad): void;
+
+    getSquads(): Squad[];
+
+    getUniqueName(): string;
+}
+
+export type MissionActionNoop = {
+    type: "noop";
+};
+export type MissionActionCreateSquad = {
+    type: "createSquad";
+    name: string;
+    behaviour: SquadBehaviour;
+};
+export type MissionActionDisband = {
+    type: "disband";
+};
+
+export type MissionAction = MissionActionNoop | MissionActionCreateSquad | MissionActionDisband;
+
+export interface MissionFactory {
+    // Potentially return a new mission.
+    maybeCreateMission(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        threatData: GlobalThreat,
+        existingMissions: Mission[],
+    ): Mission | undefined;
+}
+
+export const missionFactories = [new ExpansionMissionFactory()];

package/src/bot/logic/mission/missionController.ts

@@ -0,0 +1,51 @@
+// Meta-controller for forming and controlling squads.
+
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { Mission, MissionAction, MissionActionDisband, missionFactories } from "./mission.js";
+
+export class MissionController {
+    constructor(private missions: Mission[] = []) {}
+
+    public onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat | undefined) {
+        // 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: MissionAction): a is MissionActionDisband => a.type == "disband";
+        let disbandedMissions: Set<string> = 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: Mission[];
+        let missionNames: Set<String> = 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/src/bot/logic/squad/behaviours/squadExpansion.ts

@@ -0,0 +1,33 @@
+import { GameApi, PlayerData, SideType, TechnoRules } from "@chronodivide/game-api";
+import { GlobalThreat } from "../../threat/threat.js";
+import { Squad } from "../squad.js";
+import { SquadAction, SquadActionNoop, SquadBehaviour } from "../squadBehaviour.js";
+
+// Expansion or initial base.
+export class SquadExpansion implements SquadBehaviour {
+    public getDesiredComposition(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        squad: Squad,
+        threatData: GlobalThreat | undefined,
+    ): { unitName: string; priority: number; amount: number }[] {
+        // This squad desires an MCV.
+        let myMcvName = playerData.country?.side == SideType.GDI ? "AMCV" : "SMCV";
+        return [
+            {
+                unitName: myMcvName,
+                priority: 10,
+                amount: 1,
+            },
+        ];
+    }
+
+    public onAiUpdate(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        squad: Squad,
+        threatData: GlobalThreat | undefined,
+    ): SquadAction {
+        return {} as SquadActionNoop;
+    }
+}

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

@@ -0,0 +1,97 @@
+import { GameApi, PlayerData, TechnoRules, UnitData } from "@chronodivide/game-api";
+import { Mission } from "../mission/mission.js";
+import { GlobalThreat } from "../threat/threat.js";
+import { SquadAction, SquadBehaviour } from "./squadBehaviour.js";
+
+export enum SquadLiveness {
+    SquadDead,
+    SquadActive,
+}
+
+export type SquadConstructionRequest = {
+    squad: Squad;
+    unitType: TechnoRules;
+    priority: number;
+    // quantity: number
+};
+
+export class Squad {
+    constructor(
+        private name: string,
+        private behaviour: SquadBehaviour,
+        private mission: Mission | undefined,
+        private unitIds: number[] = [],
+        private liveness: SquadLiveness = SquadLiveness.SquadActive,
+        private lastLivenessUpdateTick: number = 0,
+    ) {}
+
+    public getName(): string {
+        return this.name;
+    }
+
+    public onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat | undefined): SquadAction {
+        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;
+    }
+
+    public getMission(): Mission | undefined {
+        return this.mission;
+    }
+
+    public setMission(mission: Mission | undefined) {
+        if (this.mission != undefined && this.mission != mission) {
+            this.mission.removeSquad(this);
+        }
+        this.mission = mission;
+    }
+
+    public getUnitIds(): number[] {
+        return this.unitIds;
+    }
+
+    public getUnits(gameApi: GameApi): UnitData[] {
+        return this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => unit != null)
+            .map((unit) => unit!);
+    }
+
+    public getUnitsOfType(gameApi: GameApi, f: (r: UnitData | undefined) => boolean): UnitData[] {
+        return this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter(f)
+            .map((unit) => unit!);
+    }
+
+    public removeUnit(unitIdToRemove: number): void {
+        this.unitIds = this.unitIds.filter((unitId) => unitId != unitIdToRemove);
+    }
+
+    public clearUnits(): void {
+        this.unitIds = [];
+    }
+
+    public addUnit(unitIdToAdd: number): void {
+        this.unitIds.push(unitIdToAdd);
+    }
+
+    private updateLiveness(gameApi: 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;
+            }
+        }
+    }
+
+    public getLiveness() {
+        return this.liveness;
+    }
+}

package/src/bot/logic/squad/squadBehaviour.ts

@@ -0,0 +1,43 @@
+import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { SquadExpansion } from "./behaviours/squadExpansion.js";
+import { Squad } from "./squad.js";
+
+export type SquadActionNoop = {
+    type: "noop";
+};
+export type SquadActionDisband = {
+    type: "disband";
+};
+export type SquadActionMergeInto = {
+    type: "mergeInto";
+    mergeInto: Squad;
+};
+export type SquadActionClaimUnits = {
+    type: "claimUnit";
+    unitIds: number[];
+};
+
+export type SquadAction = SquadActionNoop | SquadActionDisband | SquadActionMergeInto | SquadActionClaimUnits;
+
+export interface SquadBehaviour {
+    onAiUpdate(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        squad: Squad,
+        threatData: GlobalThreat | undefined,
+    ): SquadAction;
+
+    // State the desired composition of the Squad.
+    getDesiredComposition(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        squad: Squad,
+        threatData: GlobalThreat | undefined,
+    ): { unitName: string; priority: number; amount: number }[];
+}
+
+export const allSquadBehaviours: SquadBehaviour[] = [
+    //new SquadScouters(),
+    new SquadExpansion(),
+];

package/src/bot/logic/squad/squadController.ts

@@ -0,0 +1,66 @@
+// Meta-controller for forming and controlling squads.
+
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { Squad, SquadLiveness } from "./squad.js";
+import { SquadAction, SquadActionDisband, SquadActionMergeInto } from "./squadBehaviour.js";
+
+export class SquadController {
+    constructor(
+        private squads: Squad[] = [],
+        private unitIdToSquad: Map<number, Squad> = new Map(),
+    ) {}
+
+    public onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat | undefined) {
+        // 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: SquadAction): a is SquadActionDisband => a.type == "disband";
+        const isMerge = (a: SquadAction): a is SquadActionMergeInto => a.type == "mergeInto";
+        let disbandedSquads: Set<string> = 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 as SquadActionMergeInto;
+                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/src/bot/logic/threat/threat.ts

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

package/src/bot/logic/threat/threatCalculator.ts

@@ -0,0 +1,99 @@
+import { GameApi, MovementZone, ObjectType, PlayerData, UnitData } from "@chronodivide/game-api";
+import { GlobalThreat } from "./threat.js";
+
+export function calculateGlobalThreat(game: GameApi, playerData: PlayerData, visibleAreaPercent: number): GlobalThreat {
+    let groundUnits = game.getVisibleUnits(
+        playerData.name,
+        "hostile",
+        (r) => r.type == ObjectType.Vehicle || r.type == ObjectType.Infantry,
+    );
+    let airUnits = game.getVisibleUnits(playerData.name, "hostile", (r) => r.movementZone == MovementZone.Fly);
+    let groundDefence = game
+        .getVisibleUnits(playerData.name, "hostile", (r) => r.type == ObjectType.Building)
+        .filter((unitId) => isAntiGround(game, unitId));
+    let antiAirPower = game
+        .getVisibleUnits(playerData.name, "hostile", (r) => r.type != ObjectType.Building)
+        .filter((unitId) => isAntiAir(game, unitId));
+
+    let ourAntiGroundUnits = game
+        .getVisibleUnits(playerData.name, "self", (r) => r.isSelectableCombatant)
+        .filter((unitId) => isAntiGround(game, unitId));
+    let ourAntiAirUnits = game
+        .getVisibleUnits(playerData.name, "self", (r) => r.isSelectableCombatant)
+        .filter((unitId) => isAntiAir(game, unitId));
+    let ourGroundDefence = game
+        .getVisibleUnits(playerData.name, "self", (r) => r.type == ObjectType.Building)
+        .filter((unitId) => isAntiGround(game, unitId));
+    let ourAirUnits = game.getVisibleUnits(
+        playerData.name,
+        "self",
+        (r) => r.movementZone == MovementZone.Fly && r.isSelectableCombatant,
+    );
+
+    let observedGroundThreat = calculateFirepowerForUnits(game, groundUnits);
+    let observedAirThreat = calculateFirepowerForUnits(game, airUnits);
+    let observedAntiAirThreat = calculateFirepowerForUnits(game, antiAirPower);
+    let observedGroundDefence = calculateFirepowerForUnits(game, groundDefence);
+
+    let ourAntiGroundPower = calculateFirepowerForUnits(game, ourAntiGroundUnits);
+    let ourAntiAirPower = calculateFirepowerForUnits(game, ourAntiAirUnits);
+    let ourAirPower = calculateFirepowerForUnits(game, ourAirUnits);
+    let ourGroundDefencePower = calculateFirepowerForUnits(game, ourGroundDefence);
+
+    return new GlobalThreat(
+        visibleAreaPercent,
+        observedGroundThreat,
+        observedAirThreat,
+        observedAntiAirThreat,
+        observedGroundDefence * 0.25,
+        ourGroundDefencePower * 0.25,
+        ourAntiGroundPower,
+        ourAntiAirPower,
+        ourAirPower,
+    );
+}
+
+function isAntiGround(gameApi: GameApi, unitId: number): boolean {
+    let unit = gameApi.getUnitData(unitId);
+    if (unit && unit.primaryWeapon) {
+        return unit.primaryWeapon.projectileRules.isAntiGround;
+    }
+    return false;
+}
+
+function isAntiAir(gameApi: GameApi, unitId: number): boolean {
+    let unit = gameApi.getUnitData(unitId);
+    if (unit && unit.primaryWeapon) {
+        return unit.primaryWeapon.projectileRules.isAntiAir;
+    }
+    return false;
+}
+
+function calculateFirepowerForUnit(unitData: UnitData): number {
+    let threat = 0;
+    let hpRatio = unitData.hitPoints / Math.max(1, unitData.maxHitPoints);
+    if (unitData.primaryWeapon) {
+        threat +=
+            (hpRatio *
+                ((unitData.primaryWeapon.rules.damage + 1) * Math.sqrt(unitData.primaryWeapon.rules.range + 1))) /
+            Math.max(unitData.primaryWeapon.cooldownTicks, 1);
+    }
+    if (unitData.secondaryWeapon) {
+        threat +=
+            (hpRatio *
+                ((unitData.secondaryWeapon.rules.damage + 1) * Math.sqrt(unitData.secondaryWeapon.rules.range + 1))) /
+            Math.max(unitData.secondaryWeapon.cooldownTicks, 1);
+    }
+    return Math.min(800, threat);
+}
+
+function calculateFirepowerForUnits(game: GameApi, unitIds: number[]) {
+    let threat = 0;
+    unitIds.forEach((unitId) => {
+        let unitData = game.getUnitData(unitId);
+        if (unitData) {
+            threat += calculateFirepowerForUnit(unitData);
+        }
+    });
+    return threat;
+}