@supalosa/chronodivide-bot 0.5.4 → 0.6.4

package/src/bot/logic/mission/missions/squads/combatSquad.ts

@@ -1,160 +1,160 @@
-import {
-    ActionsApi,
-    AttackState,
-    GameApi,
-    GameMath,
-    MovementZone,
-    PlayerData,
-    UnitData,
-    Vector2,
-} from "@chronodivide/game-api";
-import { MatchAwareness } from "../../../awareness.js";
-import { getAttackWeight, manageAttackMicro, manageMoveMicro } from "./common.js";
-import { DebugLogger, isOwnedByNeutral, maxBy, minBy } from "../../../common/utils.js";
-import { ActionBatcher, BatchableAction } from "../../actionBatcher.js";
-import { Squad } from "./squad.js";
-import { Mission, MissionAction, grabCombatants, 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;
-
-enum SquadState {
-    Gathering,
-    Attacking,
-}
-
-export class CombatSquad implements Squad {
-    private lastCommand: number | null = null;
-    private state = SquadState.Gathering;
-
-    private debugLastTarget: string | undefined;
-
-    private lastOrderGiven: { [unitId: number]: BatchableAction } = {};
-
-    /**
-     *
-     * @param rallyArea the initial location to grab combatants
-     * @param targetArea
-     * @param radius
-     */
-    constructor(
-        private rallyArea: Vector2,
-        private targetArea: Vector2,
-        private radius: number,
-    ) {}
-
-    public getGlobalDebugText(): string | undefined {
-        return this.debugLastTarget ?? "<none>";
-    }
-
-    public setAttackArea(targetArea: Vector2) {
-        this.targetArea = targetArea;
-    }
-
-    public onAiUpdate(
-        gameApi: GameApi,
-        actionsApi: ActionsApi,
-        actionBatcher: ActionBatcher,
-        playerData: PlayerData,
-        mission: Mission<any>,
-        matchAwareness: MatchAwareness,
-        logger: DebugLogger,
-    ): MissionAction {
-        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: UnitData) =>
-                    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)) as UnitData[];
-
-                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.
-     */
-    private submitActionIfNew(actionBatcher: ActionBatcher, action: BatchableAction) {
-        const lastAction = this.lastOrderGiven[action.unitId];
-        if (!lastAction || !lastAction.isSameAs(action)) {
-            actionBatcher.push(action);
-            this.lastOrderGiven[action.unitId] = action;
-        }
-    }
-}
+import {
+    ActionsApi,
+    AttackState,
+    GameApi,
+    GameMath,
+    MovementZone,
+    PlayerData,
+    UnitData,
+    Vector2,
+} from "@chronodivide/game-api";
+import { MatchAwareness } from "../../../awareness.js";
+import { getAttackWeight, manageAttackMicro, manageMoveMicro } from "./common.js";
+import { DebugLogger, isOwnedByNeutral, maxBy, minBy } from "../../../common/utils.js";
+import { ActionBatcher, BatchableAction } from "../../actionBatcher.js";
+import { Squad } from "./squad.js";
+import { Mission, MissionAction, grabCombatants, 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;
+
+enum SquadState {
+    Gathering,
+    Attacking,
+}
+
+export class CombatSquad implements Squad {
+    private lastCommand: number | null = null;
+    private state = SquadState.Gathering;
+
+    private debugLastTarget: string | undefined;
+
+    private lastOrderGiven: { [unitId: number]: BatchableAction } = {};
+
+    /**
+     *
+     * @param rallyArea the initial location to grab combatants
+     * @param targetArea
+     * @param radius
+     */
+    constructor(
+        private rallyArea: Vector2,
+        private targetArea: Vector2,
+        private radius: number,
+    ) {}
+
+    public getGlobalDebugText(): string | undefined {
+        return this.debugLastTarget ?? "<none>";
+    }
+
+    public setAttackArea(targetArea: Vector2) {
+        this.targetArea = targetArea;
+    }
+
+    public onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        actionBatcher: ActionBatcher,
+        playerData: PlayerData,
+        mission: Mission<any>,
+        matchAwareness: MatchAwareness,
+        logger: DebugLogger,
+    ): MissionAction {
+        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: UnitData) =>
+                    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)) as UnitData[];
+
+                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.
+     */
+    private submitActionIfNew(actionBatcher: ActionBatcher, action: BatchableAction) {
+        const lastAction = this.lastOrderGiven[action.unitId];
+        if (!lastAction || !lastAction.isSameAs(action)) {
+            actionBatcher.push(action);
+            this.lastOrderGiven[action.unitId] = action;
+        }
+    }
+}

package/src/bot/logic/mission/missions/squads/common.ts

@@ -1,63 +1,63 @@
-import { AttackState, ObjectType, OrderType, StanceType, UnitData, 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: UnitData, attackPoint: Vector2): BatchableAction {
-    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: UnitData, target: UnitData): BatchableAction {
-    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 = 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: UnitData, target: UnitData): number | null {
-    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, UnitData, 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: UnitData, attackPoint: Vector2): BatchableAction {
+    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: UnitData, target: UnitData): BatchableAction {
+    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 = 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: UnitData, target: UnitData): number | null {
+    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));
+}

package/src/bot/logic/mission/missions/squads/squad.ts

@@ -1,19 +1,19 @@
-import { ActionsApi, GameApi, PlayerData } from "@chronodivide/game-api";
-import { ActionBatcher } from "../../actionBatcher";
-import { Mission, MissionAction } from "../../mission";
-import { MatchAwareness } from "../../../awareness";
-import { DebugLogger } from "../../../common/utils";
-
-export interface Squad {
-    onAiUpdate(
-        gameApi: GameApi,
-        actionsApi: ActionsApi,
-        actionBatcher: ActionBatcher,
-        playerData: PlayerData,
-        mission: Mission<any>,
-        matchAwareness: MatchAwareness,
-        logger: DebugLogger,
-    ): MissionAction;
-
-    getGlobalDebugText(): string | undefined;
-}
+import { ActionsApi, GameApi, PlayerData } from "@chronodivide/game-api";
+import { ActionBatcher } from "../../actionBatcher";
+import { Mission, MissionAction } from "../../mission";
+import { MatchAwareness } from "../../../awareness";
+import { DebugLogger } from "../../../common/utils";
+
+export interface Squad {
+    onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        actionBatcher: ActionBatcher,
+        playerData: PlayerData,
+        mission: Mission<any>,
+        matchAwareness: MatchAwareness,
+        logger: DebugLogger,
+    ): MissionAction;
+
+    getGlobalDebugText(): string | undefined;
+}

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

@@ -1,15 +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
-    ) {}
-}
+// 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
+    ) {}
+}