@supalosa/chronodivide-bot 0.5.3 → 0.6.4

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

@@ -1,13 +1,13 @@
-import { ExpansionMissionFactory } from "./missions/expansionMission.js";
-import { ScoutingMissionFactory } from "./missions/scoutingMission.js";
-import { AttackMissionFactory } from "./missions/attackMission.js";
-import { DefenceMissionFactory } from "./missions/defenceMission.js";
-import { EngineerMissionFactory } from "./missions/engineerMission.js";
-export const createMissionFactories = () => [
-    new ExpansionMissionFactory(),
-    new ScoutingMissionFactory(),
-    new AttackMissionFactory(),
-    new DefenceMissionFactory(),
-    new EngineerMissionFactory(),
-];
+import { ExpansionMissionFactory } from "./missions/expansionMission.js";
+import { ScoutingMissionFactory } from "./missions/scoutingMission.js";
+import { AttackMissionFactory } from "./missions/attackMission.js";
+import { DefenceMissionFactory } from "./missions/defenceMission.js";
+import { EngineerMissionFactory } from "./missions/engineerMission.js";
+export const createMissionFactories = () => [
+    new ExpansionMissionFactory(),
+    new ScoutingMissionFactory(),
+    new AttackMissionFactory(),
+    new DefenceMissionFactory(),
+    new EngineerMissionFactory(),
+];
 //# sourceMappingURL=missionFactories.js.map

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

@@ -1,215 +1,215 @@
-import { ObjectType, SideType, Vector2 } from "@chronodivide/game-api";
-import { CombatSquad } from "./squads/combatSquad.js";
-import { Mission, disbandMission, noop, requestUnits } from "../mission.js";
-import { RetreatMission } from "./retreatMission.js";
-import { countBy, isOwnedByNeutral, maxBy } from "../../common/utils.js";
-import { getSovietComposition } from "../../composition/sovietCompositions.js";
-import { getAlliedCompositions } from "../../composition/alliedCompositions.js";
-import { manageMoveMicro } from "./squads/common.js";
-export var AttackFailReason;
-(function (AttackFailReason) {
-    AttackFailReason[AttackFailReason["NoTargets"] = 0] = "NoTargets";
-    AttackFailReason[AttackFailReason["DefenceTooStrong"] = 1] = "DefenceTooStrong";
-})(AttackFailReason || (AttackFailReason = {}));
-var AttackMissionState;
-(function (AttackMissionState) {
-    AttackMissionState[AttackMissionState["Preparing"] = 0] = "Preparing";
-    AttackMissionState[AttackMissionState["Attacking"] = 1] = "Attacking";
-    AttackMissionState[AttackMissionState["Retreating"] = 2] = "Retreating";
-})(AttackMissionState || (AttackMissionState = {}));
-const NO_TARGET_RETARGET_TICKS = 450;
-const NO_TARGET_IDLE_TIMEOUT_TICKS = 900;
-function calculateTargetComposition(gameApi, playerData, matchAwareness) {
-    if (!playerData.country) {
-        throw new Error(`player ${playerData.name} has no country`);
-    }
-    else if (playerData.country.side === SideType.Nod) {
-        return getSovietComposition(gameApi, playerData, matchAwareness);
-    }
-    else {
-        return getAlliedCompositions(gameApi, playerData, matchAwareness);
-    }
-}
-const ATTACK_MISSION_PRIORITY_RAMP = 1.01;
-const ATTACK_MISSION_MAX_PRIORITY = 50;
-/**
- * A mission that tries to attack a certain area.
- */
-export class AttackMission extends Mission {
-    constructor(uniqueName, priority, rallyArea, attackArea, radius, composition, logger) {
-        super(uniqueName, logger);
-        this.priority = priority;
-        this.attackArea = attackArea;
-        this.radius = radius;
-        this.composition = composition;
-        this.lastTargetSeenAt = 0;
-        this.hasPickedNewTarget = false;
-        this.state = AttackMissionState.Preparing;
-        this.squad = new CombatSquad(rallyArea, attackArea, radius);
-    }
-    _onAiUpdate(gameApi, actionsApi, playerData, matchAwareness, actionBatcher) {
-        switch (this.state) {
-            case AttackMissionState.Preparing:
-                return this.handlePreparingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher);
-            case AttackMissionState.Attacking:
-                return this.handleAttackingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher);
-            case AttackMissionState.Retreating:
-                return this.handleRetreatingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher);
-        }
-    }
-    handlePreparingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher) {
-        const currentComposition = countBy(this.getUnits(gameApi), (unit) => unit.name);
-        const missingUnits = Object.entries(this.composition).filter(([unitType, targetAmount]) => {
-            return !currentComposition[unitType] || currentComposition[unitType] < targetAmount;
-        });
-        if (missingUnits.length > 0) {
-            this.priority = Math.min(this.priority * ATTACK_MISSION_PRIORITY_RAMP, ATTACK_MISSION_MAX_PRIORITY);
-            return requestUnits(missingUnits.map(([unitName]) => unitName), this.priority);
-        }
-        else {
-            this.priority = ATTACK_MISSION_INITIAL_PRIORITY;
-            this.state = AttackMissionState.Attacking;
-            return noop();
-        }
-    }
-    handleAttackingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher) {
-        if (this.getUnitIds().length === 0) {
-            // TODO: disband directly (we no longer retreat when losing)
-            this.state = AttackMissionState.Retreating;
-            return noop();
-        }
-        const foundTargets = matchAwareness
-            .getHostilesNearPoint2d(this.attackArea, this.radius)
-            .map((unit) => gameApi.getUnitData(unit.unitId))
-            .filter((unit) => !isOwnedByNeutral(unit));
-        const update = this.squad.onAiUpdate(gameApi, actionsApi, actionBatcher, playerData, this, matchAwareness, this.logger);
-        if (update.type !== "noop") {
-            return update;
-        }
-        if (foundTargets.length > 0) {
-            this.lastTargetSeenAt = gameApi.getCurrentTick();
-            this.hasPickedNewTarget = false;
-        }
-        else if (gameApi.getCurrentTick() > this.lastTargetSeenAt + NO_TARGET_IDLE_TIMEOUT_TICKS) {
-            return disbandMission(AttackFailReason.NoTargets);
-        }
-        else if (!this.hasPickedNewTarget &&
-            gameApi.getCurrentTick() > this.lastTargetSeenAt + NO_TARGET_RETARGET_TICKS) {
-            const newTarget = generateTarget(gameApi, playerData, matchAwareness);
-            if (newTarget) {
-                this.squad.setAttackArea(newTarget);
-                this.hasPickedNewTarget = true;
-            }
-        }
-        return noop();
-    }
-    handleRetreatingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher) {
-        this.getUnits(gameApi).forEach((unitId) => {
-            actionBatcher.push(manageMoveMicro(unitId, matchAwareness.getMainRallyPoint()));
-        });
-        return disbandMission();
-    }
-    getGlobalDebugText() {
-        return this.squad.getGlobalDebugText() ?? "<none>";
-    }
-    getState() {
-        return this.state;
-    }
-    // This mission can give up its units while preparing.
-    isUnitsLocked() {
-        return this.state !== AttackMissionState.Preparing;
-    }
-    getPriority() {
-        return this.priority;
-    }
-}
-// Calculates the weight for initiating an attack on the position of a unit or building.
-// This is separate from unit micro; the squad will be ordered to attack in the vicinity of the point.
-const getTargetWeight = (unitData, tryFocusHarvester) => {
-    if (tryFocusHarvester && unitData.rules.harvester) {
-        return 100000;
-    }
-    else if (unitData.type === ObjectType.Building) {
-        return unitData.maxHitPoints * 10;
-    }
-    else {
-        return unitData.maxHitPoints;
-    }
-};
-function generateTarget(gameApi, playerData, matchAwareness, includeBaseLocations = false) {
-    // Randomly decide between harvester and base.
-    try {
-        const tryFocusHarvester = gameApi.generateRandomInt(0, 1) === 0;
-        const enemyUnits = gameApi
-            .getVisibleUnits(playerData.name, "enemy")
-            .map((unitId) => gameApi.getUnitData(unitId))
-            .filter((u) => !!u && gameApi.getPlayerData(u.owner).isCombatant);
-        const maxUnit = maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
-        if (maxUnit) {
-            return new Vector2(maxUnit.tile.rx, maxUnit.tile.ry);
-        }
-        if (includeBaseLocations) {
-            const mapApi = gameApi.mapApi;
-            const enemyPlayers = gameApi
-                .getPlayers()
-                .map(gameApi.getPlayerData)
-                .filter((otherPlayer) => !gameApi.areAlliedPlayers(playerData.name, otherPlayer.name));
-            const unexploredEnemyLocations = enemyPlayers.filter((otherPlayer) => {
-                const tile = mapApi.getTile(otherPlayer.startLocation.x, otherPlayer.startLocation.y);
-                if (!tile) {
-                    return false;
-                }
-                return !mapApi.isVisibleTile(tile, playerData.name);
-            });
-            if (unexploredEnemyLocations.length > 0) {
-                const idx = gameApi.generateRandomInt(0, unexploredEnemyLocations.length - 1);
-                return unexploredEnemyLocations[idx].startLocation;
-            }
-        }
-    }
-    catch (err) {
-        // There's a crash here when accessing a building that got destroyed. Will catch and ignore or now.
-        return null;
-    }
-    return null;
-}
-// Number of ticks between attacking visible targets.
-const VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS = 120;
-// Number of ticks between attacking "bases" (enemy starting locations).
-const BASE_ATTACK_COOLDOWN_TICKS = 1800;
-const ATTACK_MISSION_INITIAL_PRIORITY = 1;
-export class AttackMissionFactory {
-    constructor(lastAttackAt = -VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS) {
-        this.lastAttackAt = lastAttackAt;
-    }
-    getName() {
-        return "AttackMissionFactory";
-    }
-    maybeCreateMissions(gameApi, playerData, matchAwareness, missionController, logger) {
-        if (gameApi.getCurrentTick() < this.lastAttackAt + VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS) {
-            return;
-        }
-        // can only have one attack 'preparing' at once.
-        if (missionController
-            .getMissions()
-            .some((mission) => mission instanceof AttackMission && mission.getState() === AttackMissionState.Preparing)) {
-            return;
-        }
-        const attackRadius = 10;
-        const includeEnemyBases = gameApi.getCurrentTick() > this.lastAttackAt + BASE_ATTACK_COOLDOWN_TICKS;
-        const attackArea = generateTarget(gameApi, playerData, matchAwareness, includeEnemyBases);
-        if (!attackArea) {
-            return;
-        }
-        const squadName = "attack_" + gameApi.getCurrentTick();
-        const composition = calculateTargetComposition(gameApi, playerData, matchAwareness);
-        const tryAttack = missionController.addMission(new AttackMission(squadName, ATTACK_MISSION_INITIAL_PRIORITY, matchAwareness.getMainRallyPoint(), attackArea, attackRadius, composition, logger).then((unitIds, reason) => {
-            missionController.addMission(new RetreatMission("retreat-from-" + squadName + gameApi.getCurrentTick(), matchAwareness.getMainRallyPoint(), unitIds, logger));
-        }));
-        if (tryAttack) {
-            this.lastAttackAt = gameApi.getCurrentTick();
-        }
-    }
-    onMissionFailed(gameApi, playerData, matchAwareness, failedMission, failureReason, missionController) { }
-}
+import { ObjectType, SideType, Vector2 } from "@chronodivide/game-api";
+import { CombatSquad } from "./squads/combatSquad.js";
+import { Mission, disbandMission, noop, requestUnits } from "../mission.js";
+import { RetreatMission } from "./retreatMission.js";
+import { countBy, isOwnedByNeutral, maxBy } from "../../common/utils.js";
+import { getSovietComposition } from "../../composition/sovietCompositions.js";
+import { getAlliedCompositions } from "../../composition/alliedCompositions.js";
+import { manageMoveMicro } from "./squads/common.js";
+export var AttackFailReason;
+(function (AttackFailReason) {
+    AttackFailReason[AttackFailReason["NoTargets"] = 0] = "NoTargets";
+    AttackFailReason[AttackFailReason["DefenceTooStrong"] = 1] = "DefenceTooStrong";
+})(AttackFailReason || (AttackFailReason = {}));
+var AttackMissionState;
+(function (AttackMissionState) {
+    AttackMissionState[AttackMissionState["Preparing"] = 0] = "Preparing";
+    AttackMissionState[AttackMissionState["Attacking"] = 1] = "Attacking";
+    AttackMissionState[AttackMissionState["Retreating"] = 2] = "Retreating";
+})(AttackMissionState || (AttackMissionState = {}));
+const NO_TARGET_RETARGET_TICKS = 450;
+const NO_TARGET_IDLE_TIMEOUT_TICKS = 900;
+function calculateTargetComposition(gameApi, playerData, matchAwareness) {
+    if (!playerData.country) {
+        throw new Error(`player ${playerData.name} has no country`);
+    }
+    else if (playerData.country.side === SideType.Nod) {
+        return getSovietComposition(gameApi, playerData, matchAwareness);
+    }
+    else {
+        return getAlliedCompositions(gameApi, playerData, matchAwareness);
+    }
+}
+const ATTACK_MISSION_PRIORITY_RAMP = 1.01;
+const ATTACK_MISSION_MAX_PRIORITY = 50;
+/**
+ * A mission that tries to attack a certain area.
+ */
+export class AttackMission extends Mission {
+    constructor(uniqueName, priority, rallyArea, attackArea, radius, composition, logger) {
+        super(uniqueName, logger);
+        this.priority = priority;
+        this.attackArea = attackArea;
+        this.radius = radius;
+        this.composition = composition;
+        this.lastTargetSeenAt = 0;
+        this.hasPickedNewTarget = false;
+        this.state = AttackMissionState.Preparing;
+        this.squad = new CombatSquad(rallyArea, attackArea, radius);
+    }
+    _onAiUpdate(gameApi, actionsApi, playerData, matchAwareness, actionBatcher) {
+        switch (this.state) {
+            case AttackMissionState.Preparing:
+                return this.handlePreparingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher);
+            case AttackMissionState.Attacking:
+                return this.handleAttackingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher);
+            case AttackMissionState.Retreating:
+                return this.handleRetreatingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher);
+        }
+    }
+    handlePreparingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher) {
+        const currentComposition = countBy(this.getUnits(gameApi), (unit) => unit.name);
+        const missingUnits = Object.entries(this.composition).filter(([unitType, targetAmount]) => {
+            return !currentComposition[unitType] || currentComposition[unitType] < targetAmount;
+        });
+        if (missingUnits.length > 0) {
+            this.priority = Math.min(this.priority * ATTACK_MISSION_PRIORITY_RAMP, ATTACK_MISSION_MAX_PRIORITY);
+            return requestUnits(missingUnits.map(([unitName]) => unitName), this.priority);
+        }
+        else {
+            this.priority = ATTACK_MISSION_INITIAL_PRIORITY;
+            this.state = AttackMissionState.Attacking;
+            return noop();
+        }
+    }
+    handleAttackingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher) {
+        if (this.getUnitIds().length === 0) {
+            // TODO: disband directly (we no longer retreat when losing)
+            this.state = AttackMissionState.Retreating;
+            return noop();
+        }
+        const foundTargets = matchAwareness
+            .getHostilesNearPoint2d(this.attackArea, this.radius)
+            .map((unit) => gameApi.getUnitData(unit.unitId))
+            .filter((unit) => !isOwnedByNeutral(unit));
+        const update = this.squad.onAiUpdate(gameApi, actionsApi, actionBatcher, playerData, this, matchAwareness, this.logger);
+        if (update.type !== "noop") {
+            return update;
+        }
+        if (foundTargets.length > 0) {
+            this.lastTargetSeenAt = gameApi.getCurrentTick();
+            this.hasPickedNewTarget = false;
+        }
+        else if (gameApi.getCurrentTick() > this.lastTargetSeenAt + NO_TARGET_IDLE_TIMEOUT_TICKS) {
+            return disbandMission(AttackFailReason.NoTargets);
+        }
+        else if (!this.hasPickedNewTarget &&
+            gameApi.getCurrentTick() > this.lastTargetSeenAt + NO_TARGET_RETARGET_TICKS) {
+            const newTarget = generateTarget(gameApi, playerData, matchAwareness);
+            if (newTarget) {
+                this.squad.setAttackArea(newTarget);
+                this.hasPickedNewTarget = true;
+            }
+        }
+        return noop();
+    }
+    handleRetreatingState(gameApi, actionsApi, playerData, matchAwareness, actionBatcher) {
+        this.getUnits(gameApi).forEach((unitId) => {
+            actionBatcher.push(manageMoveMicro(unitId, matchAwareness.getMainRallyPoint()));
+        });
+        return disbandMission();
+    }
+    getGlobalDebugText() {
+        return this.squad.getGlobalDebugText() ?? "<none>";
+    }
+    getState() {
+        return this.state;
+    }
+    // This mission can give up its units while preparing.
+    isUnitsLocked() {
+        return this.state !== AttackMissionState.Preparing;
+    }
+    getPriority() {
+        return this.priority;
+    }
+}
+// Calculates the weight for initiating an attack on the position of a unit or building.
+// This is separate from unit micro; the squad will be ordered to attack in the vicinity of the point.
+const getTargetWeight = (unitData, tryFocusHarvester) => {
+    if (tryFocusHarvester && unitData.rules.harvester) {
+        return 100000;
+    }
+    else if (unitData.type === ObjectType.Building) {
+        return unitData.maxHitPoints * 10;
+    }
+    else {
+        return unitData.maxHitPoints;
+    }
+};
+function generateTarget(gameApi, playerData, matchAwareness, includeBaseLocations = false) {
+    // Randomly decide between harvester and base.
+    try {
+        const tryFocusHarvester = gameApi.generateRandomInt(0, 1) === 0;
+        const enemyUnits = gameApi
+            .getVisibleUnits(playerData.name, "enemy")
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((u) => !!u && gameApi.getPlayerData(u.owner).isCombatant);
+        const maxUnit = maxBy(enemyUnits, (u) => getTargetWeight(u, tryFocusHarvester));
+        if (maxUnit) {
+            return new Vector2(maxUnit.tile.rx, maxUnit.tile.ry);
+        }
+        if (includeBaseLocations) {
+            const mapApi = gameApi.mapApi;
+            const enemyPlayers = gameApi
+                .getPlayers()
+                .map(gameApi.getPlayerData)
+                .filter((otherPlayer) => !gameApi.areAlliedPlayers(playerData.name, otherPlayer.name));
+            const unexploredEnemyLocations = enemyPlayers.filter((otherPlayer) => {
+                const tile = mapApi.getTile(otherPlayer.startLocation.x, otherPlayer.startLocation.y);
+                if (!tile) {
+                    return false;
+                }
+                return !mapApi.isVisibleTile(tile, playerData.name);
+            });
+            if (unexploredEnemyLocations.length > 0) {
+                const idx = gameApi.generateRandomInt(0, unexploredEnemyLocations.length - 1);
+                return unexploredEnemyLocations[idx].startLocation;
+            }
+        }
+    }
+    catch (err) {
+        // There's a crash here when accessing a building that got destroyed. Will catch and ignore or now.
+        return null;
+    }
+    return null;
+}
+// Number of ticks between attacking visible targets.
+const VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS = 120;
+// Number of ticks between attacking "bases" (enemy starting locations).
+const BASE_ATTACK_COOLDOWN_TICKS = 1800;
+const ATTACK_MISSION_INITIAL_PRIORITY = 1;
+export class AttackMissionFactory {
+    constructor(lastAttackAt = -VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS) {
+        this.lastAttackAt = lastAttackAt;
+    }
+    getName() {
+        return "AttackMissionFactory";
+    }
+    maybeCreateMissions(gameApi, playerData, matchAwareness, missionController, logger) {
+        if (gameApi.getCurrentTick() < this.lastAttackAt + VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS) {
+            return;
+        }
+        // can only have one attack 'preparing' at once.
+        if (missionController
+            .getMissions()
+            .some((mission) => mission instanceof AttackMission && mission.getState() === AttackMissionState.Preparing)) {
+            return;
+        }
+        const attackRadius = 10;
+        const includeEnemyBases = gameApi.getCurrentTick() > this.lastAttackAt + BASE_ATTACK_COOLDOWN_TICKS;
+        const attackArea = generateTarget(gameApi, playerData, matchAwareness, includeEnemyBases);
+        if (!attackArea) {
+            return;
+        }
+        const squadName = "attack_" + gameApi.getCurrentTick();
+        const composition = calculateTargetComposition(gameApi, playerData, matchAwareness);
+        const tryAttack = missionController.addMission(new AttackMission(squadName, ATTACK_MISSION_INITIAL_PRIORITY, matchAwareness.getMainRallyPoint(), attackArea, attackRadius, composition, logger).then((unitIds, reason) => {
+            missionController.addMission(new RetreatMission("retreat-from-" + squadName + gameApi.getCurrentTick(), matchAwareness.getMainRallyPoint(), unitIds, logger));
+        }));
+        if (tryAttack) {
+            this.lastAttackAt = gameApi.getCurrentTick();
+        }
+    }
+    onMissionFailed(gameApi, playerData, matchAwareness, failedMission, failureReason, missionController) { }
+}
 //# sourceMappingURL=attackMission.js.map

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

@@ -1,83 +1,83 @@
-import { Vector2 } from "@chronodivide/game-api";
-import { Mission, grabCombatants, noop, releaseUnits } from "../mission.js";
-import { CombatSquad } from "./squads/combatSquad.js";
-import { isOwnedByNeutral } from "../../common/utils.js";
-export const MAX_PRIORITY = 100;
-export const PRIORITY_INCREASE_PER_TICK_RATIO = 1.025;
-/**
- * A mission that tries to defend a certain area.
- */
-export class DefenceMission extends Mission {
-    constructor(uniqueName, priority, rallyArea, defenceArea, radius, logger) {
-        super(uniqueName, logger);
-        this.priority = priority;
-        this.defenceArea = defenceArea;
-        this.radius = radius;
-        this.squad = new CombatSquad(rallyArea, defenceArea, radius);
-    }
-    _onAiUpdate(gameApi, actionsApi, playerData, matchAwareness, actionBatcher) {
-        // Dispatch missions.
-        const foundTargets = matchAwareness
-            .getHostilesNearPoint2d(this.defenceArea, this.radius)
-            .map((unit) => gameApi.getUnitData(unit.unitId))
-            .filter((unit) => !isOwnedByNeutral(unit));
-        const update = this.squad.onAiUpdate(gameApi, actionsApi, actionBatcher, playerData, this, matchAwareness, this.logger);
-        if (update.type !== "noop") {
-            return update;
-        }
-        if (foundTargets.length === 0) {
-            this.priority = 0;
-            if (this.getUnitIds().length > 0) {
-                this.logger(`(Defence Mission ${this.getUniqueName()}): No targets found, releasing units.`);
-                return releaseUnits(this.getUnitIds());
-            }
-            else {
-                return noop();
-            }
-        }
-        else {
-            const targetUnit = foundTargets[0];
-            this.logger(`(Defence Mission ${this.getUniqueName()}): Focused on target ${targetUnit?.name} (${foundTargets.length} found in area ${this.radius})`);
-            this.squad.setAttackArea(new Vector2(foundTargets[0].tile.rx, foundTargets[0].tile.ry));
-            this.priority = MAX_PRIORITY; // Math.min(MAX_PRIORITY, this.priority * PRIORITY_INCREASE_PER_TICK_RATIO);
-            return grabCombatants(playerData.startLocation, this.priority);
-        }
-        //return requestUnits(["E1", "E2", "FV", "HTK", "MTNK", "HTNK"], this.priority);
-    }
-    getGlobalDebugText() {
-        return this.squad.getGlobalDebugText() ?? "<none>";
-    }
-    getPriority() {
-        return this.priority;
-    }
-}
-const DEFENCE_CHECK_TICKS = 30;
-// Starting radius around the player's base to trigger defense.
-const DEFENCE_STARTING_RADIUS = 10;
-// Every game tick, we increase the defendable area by this amount.
-const DEFENCE_RADIUS_INCREASE_PER_GAME_TICK = 0.001;
-export class DefenceMissionFactory {
-    constructor() {
-        this.lastDefenceCheckAt = 0;
-    }
-    getName() {
-        return "DefenceMissionFactory";
-    }
-    maybeCreateMissions(gameApi, playerData, matchAwareness, missionController, logger) {
-        if (gameApi.getCurrentTick() < this.lastDefenceCheckAt + DEFENCE_CHECK_TICKS) {
-            return;
-        }
-        this.lastDefenceCheckAt = gameApi.getCurrentTick();
-        const defendableRadius = DEFENCE_STARTING_RADIUS + DEFENCE_RADIUS_INCREASE_PER_GAME_TICK * gameApi.getCurrentTick();
-        const enemiesNearSpawn = matchAwareness
-            .getHostilesNearPoint2d(playerData.startLocation, defendableRadius)
-            .map((unit) => gameApi.getUnitData(unit.unitId))
-            .filter((unit) => !isOwnedByNeutral(unit));
-        if (enemiesNearSpawn.length > 0) {
-            logger(`Starting defence mission, ${enemiesNearSpawn.length} found in radius ${defendableRadius} (tick ${gameApi.getCurrentTick()})`);
-            missionController.addMission(new DefenceMission("globalDefence", 10, matchAwareness.getMainRallyPoint(), playerData.startLocation, defendableRadius * 1.2, logger));
-        }
-    }
-    onMissionFailed(gameApi, playerData, matchAwareness, failedMission, failureReason, missionController) { }
-}
+import { Vector2 } from "@chronodivide/game-api";
+import { Mission, grabCombatants, noop, releaseUnits } from "../mission.js";
+import { CombatSquad } from "./squads/combatSquad.js";
+import { isOwnedByNeutral } from "../../common/utils.js";
+export const MAX_PRIORITY = 100;
+export const PRIORITY_INCREASE_PER_TICK_RATIO = 1.025;
+/**
+ * A mission that tries to defend a certain area.
+ */
+export class DefenceMission extends Mission {
+    constructor(uniqueName, priority, rallyArea, defenceArea, radius, logger) {
+        super(uniqueName, logger);
+        this.priority = priority;
+        this.defenceArea = defenceArea;
+        this.radius = radius;
+        this.squad = new CombatSquad(rallyArea, defenceArea, radius);
+    }
+    _onAiUpdate(gameApi, actionsApi, playerData, matchAwareness, actionBatcher) {
+        // Dispatch missions.
+        const foundTargets = matchAwareness
+            .getHostilesNearPoint2d(this.defenceArea, this.radius)
+            .map((unit) => gameApi.getUnitData(unit.unitId))
+            .filter((unit) => !isOwnedByNeutral(unit));
+        const update = this.squad.onAiUpdate(gameApi, actionsApi, actionBatcher, playerData, this, matchAwareness, this.logger);
+        if (update.type !== "noop") {
+            return update;
+        }
+        if (foundTargets.length === 0) {
+            this.priority = 0;
+            if (this.getUnitIds().length > 0) {
+                this.logger(`(Defence Mission ${this.getUniqueName()}): No targets found, releasing units.`);
+                return releaseUnits(this.getUnitIds());
+            }
+            else {
+                return noop();
+            }
+        }
+        else {
+            const targetUnit = foundTargets[0];
+            this.logger(`(Defence Mission ${this.getUniqueName()}): Focused on target ${targetUnit?.name} (${foundTargets.length} found in area ${this.radius})`);
+            this.squad.setAttackArea(new Vector2(foundTargets[0].tile.rx, foundTargets[0].tile.ry));
+            this.priority = MAX_PRIORITY; // Math.min(MAX_PRIORITY, this.priority * PRIORITY_INCREASE_PER_TICK_RATIO);
+            return grabCombatants(playerData.startLocation, this.priority);
+        }
+        //return requestUnits(["E1", "E2", "FV", "HTK", "MTNK", "HTNK"], this.priority);
+    }
+    getGlobalDebugText() {
+        return this.squad.getGlobalDebugText() ?? "<none>";
+    }
+    getPriority() {
+        return this.priority;
+    }
+}
+const DEFENCE_CHECK_TICKS = 30;
+// Starting radius around the player's base to trigger defense.
+const DEFENCE_STARTING_RADIUS = 10;
+// Every game tick, we increase the defendable area by this amount.
+const DEFENCE_RADIUS_INCREASE_PER_GAME_TICK = 0.001;
+export class DefenceMissionFactory {
+    constructor() {
+        this.lastDefenceCheckAt = 0;
+    }
+    getName() {
+        return "DefenceMissionFactory";
+    }
+    maybeCreateMissions(gameApi, playerData, matchAwareness, missionController, logger) {
+        if (gameApi.getCurrentTick() < this.lastDefenceCheckAt + DEFENCE_CHECK_TICKS) {
+            return;
+        }
+        this.lastDefenceCheckAt = gameApi.getCurrentTick();
+        const defendableRadius = DEFENCE_STARTING_RADIUS + DEFENCE_RADIUS_INCREASE_PER_GAME_TICK * gameApi.getCurrentTick();
+        const enemiesNearSpawn = matchAwareness
+            .getHostilesNearPoint2d(playerData.startLocation, defendableRadius)
+            .map((unit) => gameApi.getUnitData(unit.unitId))
+            .filter((unit) => !isOwnedByNeutral(unit));
+        if (enemiesNearSpawn.length > 0) {
+            logger(`Starting defence mission, ${enemiesNearSpawn.length} found in radius ${defendableRadius} (tick ${gameApi.getCurrentTick()})`);
+            missionController.addMission(new DefenceMission("globalDefence", 10, matchAwareness.getMainRallyPoint(), playerData.startLocation, defendableRadius * 1.2, logger));
+        }
+    }
+    onMissionFailed(gameApi, playerData, matchAwareness, failedMission, failureReason, missionController) { }
+}
 //# sourceMappingURL=defenceMission.js.map