@supalosa/chronodivide-bot 0.5.3 → 0.6.4

package/dist/bot/logic/mission/missions/squads/combatSquad.js

@@ -1,116 +1,116 @@
-import { GameMath, MovementZone, } from "@chronodivide/game-api";
-import { getAttackWeight, manageAttackMicro, manageMoveMicro } from "./common.js";
-import { isOwnedByNeutral, maxBy, minBy } from "../../../common/utils.js";
-import { noop } from "../../mission.js";
-const TARGET_UPDATE_INTERVAL_TICKS = 10;
-// 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;
-const ATTACK_SCAN_AREA = 15;
-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.lastCommand = null;
-        this.state = SquadState.Gathering;
-        this.lastOrderGiven = {};
-    }
-    getGlobalDebugText() {
-        return this.debugLastTarget ?? "<none>";
-    }
-    setAttackArea(targetArea) {
-        this.targetArea = targetArea;
-    }
-    onAiUpdate(gameApi, actionsApi, actionBatcher, playerData, mission, matchAwareness, logger) {
-        if (mission.getUnitIds().length > 0 &&
-            (!this.lastCommand || gameApi.getCurrentTick() > this.lastCommand + TARGET_UPDATE_INTERVAL_TICKS)) {
-            this.lastCommand = gameApi.getCurrentTick();
-            const centerOfMass = mission.getCenterOfMass();
-            const maxDistance = mission.getMaxDistanceToCenterOfMass();
-            const units = mission.getUnitsMatching(gameApi, (r) => r.rules.isSelectableCombatant);
-            // Only use ground units for center of mass.
-            const groundUnits = mission.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 = GameMath.sqrt(groundUnits.length) * GATHER_RATIO + MIN_GATHER_RADIUS;
-                if (centerOfMass &&
-                    maxDistance &&
-                    gameApi.mapApi.getTile(centerOfMass.x, centerOfMass.y) !== undefined &&
-                    maxDistance > requiredGatherRadius) {
-                    units.forEach((unit) => {
-                        this.submitActionIfNew(actionBatcher, manageMoveMicro(unit, centerOfMass));
-                    });
-                }
-                else {
-                    logger(`CombatSquad ${mission.getUniqueName()} switching back to attack mode (${maxDistance})`);
-                    this.state = SquadState.Attacking;
-                }
-            }
-            else {
-                const targetPoint = this.targetArea || playerData.startLocation;
-                const requiredGatherRadius = GameMath.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
-                    logger(`CombatSquad ${mission.getUniqueName()} switching back to gather (${maxDistance})`);
-                    this.state = SquadState.Gathering;
-                    return noop();
-                }
-                // The unit with the shortest range chooses the target. Otherwise, a base range of 5 is chosen.
-                const getRangeForUnit = (unit) => unit.primaryWeapon?.maxRange ?? unit.secondaryWeapon?.maxRange ?? 5;
-                const attackLeader = minBy(units, getRangeForUnit);
-                if (!attackLeader) {
-                    return noop();
-                }
-                // Find units within double the range of the leader.
-                const nearbyHostiles = matchAwareness
-                    .getHostilesNearPoint(attackLeader.tile.rx, attackLeader.tile.ry, ATTACK_SCAN_AREA)
-                    .map(({ unitId }) => gameApi.getUnitData(unitId))
-                    .filter((unit) => !isOwnedByNeutral(unit));
-                for (const unit of units) {
-                    const bestUnit = maxBy(nearbyHostiles, (target) => getAttackWeight(unit, target));
-                    if (bestUnit) {
-                        this.submitActionIfNew(actionBatcher, manageAttackMicro(unit, bestUnit));
-                        this.debugLastTarget = `Unit ${bestUnit.id.toString()}`;
-                    }
-                    else {
-                        this.submitActionIfNew(actionBatcher, manageMoveMicro(unit, targetPoint));
-                        this.debugLastTarget = `@${targetPoint.x},${targetPoint.y}`;
-                    }
-                }
-            }
-        }
-        return noop();
-    }
-    /**
-     * Sends an action to the acitonBatcher if and only if the action is different from the last action we submitted to it.
-     * Prevents spamming redundant orders, which affects performance and can also ccause the unit to sit around doing nothing.
-     */
-    submitActionIfNew(actionBatcher, action) {
-        const lastAction = this.lastOrderGiven[action.unitId];
-        if (!lastAction || !lastAction.isSameAs(action)) {
-            actionBatcher.push(action);
-            this.lastOrderGiven[action.unitId] = action;
-        }
-    }
-}
+import { GameMath, MovementZone, } from "@chronodivide/game-api";
+import { getAttackWeight, manageAttackMicro, manageMoveMicro } from "./common.js";
+import { isOwnedByNeutral, maxBy, minBy } from "../../../common/utils.js";
+import { noop } from "../../mission.js";
+const TARGET_UPDATE_INTERVAL_TICKS = 10;
+// 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;
+const ATTACK_SCAN_AREA = 15;
+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.lastCommand = null;
+        this.state = SquadState.Gathering;
+        this.lastOrderGiven = {};
+    }
+    getGlobalDebugText() {
+        return this.debugLastTarget ?? "<none>";
+    }
+    setAttackArea(targetArea) {
+        this.targetArea = targetArea;
+    }
+    onAiUpdate(gameApi, actionsApi, actionBatcher, playerData, mission, matchAwareness, logger) {
+        if (mission.getUnitIds().length > 0 &&
+            (!this.lastCommand || gameApi.getCurrentTick() > this.lastCommand + TARGET_UPDATE_INTERVAL_TICKS)) {
+            this.lastCommand = gameApi.getCurrentTick();
+            const centerOfMass = mission.getCenterOfMass();
+            const maxDistance = mission.getMaxDistanceToCenterOfMass();
+            const units = mission.getUnitsMatching(gameApi, (r) => r.rules.isSelectableCombatant);
+            // Only use ground units for center of mass.
+            const groundUnits = mission.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 = GameMath.sqrt(groundUnits.length) * GATHER_RATIO + MIN_GATHER_RADIUS;
+                if (centerOfMass &&
+                    maxDistance &&
+                    gameApi.mapApi.getTile(centerOfMass.x, centerOfMass.y) !== undefined &&
+                    maxDistance > requiredGatherRadius) {
+                    units.forEach((unit) => {
+                        this.submitActionIfNew(actionBatcher, manageMoveMicro(unit, centerOfMass));
+                    });
+                }
+                else {
+                    logger(`CombatSquad ${mission.getUniqueName()} switching back to attack mode (${maxDistance})`);
+                    this.state = SquadState.Attacking;
+                }
+            }
+            else {
+                const targetPoint = this.targetArea || playerData.startLocation;
+                const requiredGatherRadius = GameMath.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
+                    logger(`CombatSquad ${mission.getUniqueName()} switching back to gather (${maxDistance})`);
+                    this.state = SquadState.Gathering;
+                    return noop();
+                }
+                // The unit with the shortest range chooses the target. Otherwise, a base range of 5 is chosen.
+                const getRangeForUnit = (unit) => unit.primaryWeapon?.maxRange ?? unit.secondaryWeapon?.maxRange ?? 5;
+                const attackLeader = minBy(units, getRangeForUnit);
+                if (!attackLeader) {
+                    return noop();
+                }
+                // Find units within double the range of the leader.
+                const nearbyHostiles = matchAwareness
+                    .getHostilesNearPoint(attackLeader.tile.rx, attackLeader.tile.ry, ATTACK_SCAN_AREA)
+                    .map(({ unitId }) => gameApi.getUnitData(unitId))
+                    .filter((unit) => !isOwnedByNeutral(unit));
+                for (const unit of units) {
+                    const bestUnit = maxBy(nearbyHostiles, (target) => getAttackWeight(unit, target));
+                    if (bestUnit) {
+                        this.submitActionIfNew(actionBatcher, manageAttackMicro(unit, bestUnit));
+                        this.debugLastTarget = `Unit ${bestUnit.id.toString()}`;
+                    }
+                    else {
+                        this.submitActionIfNew(actionBatcher, manageMoveMicro(unit, targetPoint));
+                        this.debugLastTarget = `@${targetPoint.x},${targetPoint.y}`;
+                    }
+                }
+            }
+        }
+        return noop();
+    }
+    /**
+     * Sends an action to the acitonBatcher if and only if the action is different from the last action we submitted to it.
+     * Prevents spamming redundant orders, which affects performance and can also ccause the unit to sit around doing nothing.
+     */
+    submitActionIfNew(actionBatcher, action) {
+        const lastAction = this.lastOrderGiven[action.unitId];
+        if (!lastAction || !lastAction.isSameAs(action)) {
+            actionBatcher.push(action);
+            this.lastOrderGiven[action.unitId] = action;
+        }
+    }
+}
 //# sourceMappingURL=combatSquad.js.map

package/dist/bot/logic/mission/missions/squads/common.js

@@ -1,58 +1,58 @@
-import { AttackState, ObjectType, OrderType, StanceType, Vector2, ZoneType } from "@chronodivide/game-api";
-import { getDistanceBetweenPoints, getDistanceBetweenUnits } from "../../../map/map.js";
-import { BatchableAction } from "../../actionBatcher.js";
-const NONCE_GI_DEPLOY = 0;
-const NONCE_GI_UNDEPLOY = 1;
-// Micro methods
-export function manageMoveMicro(attacker, attackPoint) {
-    if (attacker.name === "E1") {
-        const isDeployed = attacker.stance === StanceType.Deployed;
-        if (isDeployed) {
-            return BatchableAction.noTarget(attacker.id, OrderType.DeploySelected, NONCE_GI_UNDEPLOY);
-        }
-    }
-    return BatchableAction.toPoint(attacker.id, OrderType.AttackMove, attackPoint);
-}
-export function manageAttackMicro(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)) {
-            return BatchableAction.noTarget(attacker.id, OrderType.DeploySelected, NONCE_GI_DEPLOY);
-        }
-        else if (isDeployed && distance > deployedWeaponRange) {
-            return BatchableAction.noTarget(attacker.id, OrderType.DeploySelected, NONCE_GI_UNDEPLOY);
-        }
-    }
-    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;
-    }
-    return BatchableAction.toTargetId(attacker.id, orderType, target.id);
-}
-/**
- *
- * @param attacker
- * @param target
- * @returns A number describing the weight of the given target for the attacker, or null if it should not attack it.
- */
-export function getAttackWeight(attacker, target) {
-    const { rx: x, ry: y } = attacker.tile;
-    const { rx: hX, ry: hY } = target.tile;
-    if (!attacker.primaryWeapon?.projectileRules.isAntiAir && target.zone === ZoneType.Air) {
-        return null;
-    }
-    if (!attacker.primaryWeapon?.projectileRules.isAntiGround && target.zone === ZoneType.Ground) {
-        return null;
-    }
-    return 1000000 - getDistanceBetweenPoints(new Vector2(x, y), new Vector2(hX, hY));
-}
+import { AttackState, ObjectType, OrderType, StanceType, Vector2, ZoneType } from "@chronodivide/game-api";
+import { getDistanceBetweenPoints, getDistanceBetweenUnits } from "../../../map/map.js";
+import { BatchableAction } from "../../actionBatcher.js";
+const NONCE_GI_DEPLOY = 0;
+const NONCE_GI_UNDEPLOY = 1;
+// Micro methods
+export function manageMoveMicro(attacker, attackPoint) {
+    if (attacker.name === "E1") {
+        const isDeployed = attacker.stance === StanceType.Deployed;
+        if (isDeployed) {
+            return BatchableAction.noTarget(attacker.id, OrderType.DeploySelected, NONCE_GI_UNDEPLOY);
+        }
+    }
+    return BatchableAction.toPoint(attacker.id, OrderType.AttackMove, attackPoint);
+}
+export function manageAttackMicro(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)) {
+            return BatchableAction.noTarget(attacker.id, OrderType.DeploySelected, NONCE_GI_DEPLOY);
+        }
+        else if (isDeployed && distance > deployedWeaponRange) {
+            return BatchableAction.noTarget(attacker.id, OrderType.DeploySelected, NONCE_GI_UNDEPLOY);
+        }
+    }
+    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;
+    }
+    return BatchableAction.toTargetId(attacker.id, orderType, target.id);
+}
+/**
+ *
+ * @param attacker
+ * @param target
+ * @returns A number describing the weight of the given target for the attacker, or null if it should not attack it.
+ */
+export function getAttackWeight(attacker, target) {
+    const { rx: x, ry: y } = attacker.tile;
+    const { rx: hX, ry: hY } = target.tile;
+    if (!attacker.primaryWeapon?.projectileRules.isAntiAir && target.zone === ZoneType.Air) {
+        return null;
+    }
+    if (!attacker.primaryWeapon?.projectileRules.isAntiGround && target.zone === ZoneType.Ground) {
+        return null;
+    }
+    return 1000000 - getDistanceBetweenPoints(new Vector2(x, y), new Vector2(hX, hY));
+}
 //# sourceMappingURL=common.js.map

package/dist/bot/logic/mission/missions/squads/squad.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=squad.js.map

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

@@ -1,23 +1,23 @@
-// 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;
-    }
-}
+// 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;
+    }
+}
 //# sourceMappingURL=threat.js.map

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

@@ -1,74 +1,74 @@
-import { GameMath, MovementZone, ObjectType } from "@chronodivide/game-api";
-import { GlobalThreat } from "./threat.js";
-export function calculateGlobalThreat(game, playerData, visibleAreaPercent) {
-    let groundUnits = game.getVisibleUnits(playerData.name, "enemy", (r) => r.type == ObjectType.Vehicle || r.type == ObjectType.Infantry);
-    let airUnits = game.getVisibleUnits(playerData.name, "enemy", (r) => r.movementZone == MovementZone.Fly);
-    let groundDefence = game
-        .getVisibleUnits(playerData.name, "enemy", (r) => r.type == ObjectType.Building)
-        .filter((unitId) => isAntiGround(game, unitId));
-    let antiAirPower = game
-        .getVisibleUnits(playerData.name, "enemy", (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 || r.type === ObjectType.Building)
-        .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, ourGroundDefencePower, ourAntiGroundPower, ourAntiAirPower, ourAirPower);
-}
-function isAntiGround(gameApi, unitId) {
-    let unit = gameApi.getUnitData(unitId);
-    if (unit && unit.primaryWeapon) {
-        return unit.primaryWeapon.projectileRules.isAntiGround;
-    }
-    return false;
-}
-function isAntiAir(gameApi, unitId) {
-    let unit = gameApi.getUnitData(unitId);
-    if (unit && unit.primaryWeapon) {
-        return unit.primaryWeapon.projectileRules.isAntiAir;
-    }
-    return false;
-}
-function calculateFirepowerForUnit(unitData) {
-    let threat = 0;
-    let hpRatio = unitData.hitPoints / Math.max(1, unitData.maxHitPoints);
-    if (unitData.primaryWeapon) {
-        threat +=
-            (hpRatio *
-                ((unitData.primaryWeapon.rules.damage + 1) * GameMath.sqrt(unitData.primaryWeapon.rules.range + 1))) /
-                Math.max(unitData.primaryWeapon.rules.rof, 1);
-    }
-    if (unitData.secondaryWeapon) {
-        threat +=
-            (hpRatio *
-                ((unitData.secondaryWeapon.rules.damage + 1) *
-                    GameMath.sqrt(unitData.secondaryWeapon.rules.range + 1))) /
-                Math.max(unitData.secondaryWeapon.rules.rof, 1);
-    }
-    return Math.min(800, threat);
-}
-function calculateFirepowerForUnits(game, unitIds) {
-    let threat = 0;
-    unitIds.forEach((unitId) => {
-        let unitData = game.getUnitData(unitId);
-        if (unitData) {
-            threat += calculateFirepowerForUnit(unitData);
-        }
-    });
-    return threat;
-}
+import { GameMath, MovementZone, ObjectType } from "@chronodivide/game-api";
+import { GlobalThreat } from "./threat.js";
+export function calculateGlobalThreat(game, playerData, visibleAreaPercent) {
+    let groundUnits = game.getVisibleUnits(playerData.name, "enemy", (r) => r.type == ObjectType.Vehicle || r.type == ObjectType.Infantry);
+    let airUnits = game.getVisibleUnits(playerData.name, "enemy", (r) => r.movementZone == MovementZone.Fly);
+    let groundDefence = game
+        .getVisibleUnits(playerData.name, "enemy", (r) => r.type == ObjectType.Building)
+        .filter((unitId) => isAntiGround(game, unitId));
+    let antiAirPower = game
+        .getVisibleUnits(playerData.name, "enemy", (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 || r.type === ObjectType.Building)
+        .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, ourGroundDefencePower, ourAntiGroundPower, ourAntiAirPower, ourAirPower);
+}
+function isAntiGround(gameApi, unitId) {
+    let unit = gameApi.getUnitData(unitId);
+    if (unit && unit.primaryWeapon) {
+        return unit.primaryWeapon.projectileRules.isAntiGround;
+    }
+    return false;
+}
+function isAntiAir(gameApi, unitId) {
+    let unit = gameApi.getUnitData(unitId);
+    if (unit && unit.primaryWeapon) {
+        return unit.primaryWeapon.projectileRules.isAntiAir;
+    }
+    return false;
+}
+function calculateFirepowerForUnit(unitData) {
+    let threat = 0;
+    let hpRatio = unitData.hitPoints / Math.max(1, unitData.maxHitPoints);
+    if (unitData.primaryWeapon) {
+        threat +=
+            (hpRatio *
+                ((unitData.primaryWeapon.rules.damage + 1) * GameMath.sqrt(unitData.primaryWeapon.rules.range + 1))) /
+                Math.max(unitData.primaryWeapon.rules.rof, 1);
+    }
+    if (unitData.secondaryWeapon) {
+        threat +=
+            (hpRatio *
+                ((unitData.secondaryWeapon.rules.damage + 1) *
+                    GameMath.sqrt(unitData.secondaryWeapon.rules.range + 1))) /
+                Math.max(unitData.secondaryWeapon.rules.rof, 1);
+    }
+    return Math.min(800, threat);
+}
+function calculateFirepowerForUnits(game, unitIds) {
+    let threat = 0;
+    unitIds.forEach((unitId) => {
+        let unitData = game.getUnitData(unitId);
+        if (unitData) {
+            threat += calculateFirepowerForUnit(unitData);
+        }
+    });
+    return threat;
+}
 //# sourceMappingURL=threatCalculator.js.map