@supalosa/chronodivide-bot 0.4.0 → 0.5.2

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

@@ -1,70 +1,195 @@
-import { GameApi, GameMath, MapApi, ObjectType, PlayerData, UnitData, Vector2 } from "@chronodivide/game-api";
-import { CombatSquad } from "../../squad/behaviours/combatSquad.js";
-import { Mission, MissionAction, disbandMission, noop } from "../mission.js";
-import { Squad } from "../../squad/squad.js";
+import { ActionsApi, GameApi, ObjectType, PlayerData, SideType, UnitData, Vector2 } from "@chronodivide/game-api";
+import { CombatSquad } from "./squads/combatSquad.js";
+import { Mission, MissionAction, disbandMission, noop, requestUnits } from "../mission.js";
 import { MissionFactory } from "../missionFactories.js";
 import { MatchAwareness } from "../../awareness.js";
 import { MissionController } from "../missionController.js";
 import { RetreatMission } from "./retreatMission.js";
-import { DebugLogger, maxBy } from "../../common/utils.js";
+import { DebugLogger, countBy, isOwnedByNeutral, maxBy } from "../../common/utils.js";
+import { ActionBatcher } from "../actionBatcher.js";
+import { getSovietComposition } from "../../composition/sovietCompositions.js";
+import { getAlliedCompositions } from "../../composition/alliedCompositions.js";
+import { UnitComposition } from "../../composition/common.js";
+import { manageMoveMicro } from "./squads/common.js";
 
 export enum AttackFailReason {
     NoTargets = 0,
     DefenceTooStrong = 1,
 }
 
+enum AttackMissionState {
+    Preparing = 0,
+    Attacking = 1,
+    Retreating = 2,
+}
+
 const NO_TARGET_RETARGET_TICKS = 450;
 const NO_TARGET_IDLE_TIMEOUT_TICKS = 900;
 
+function calculateTargetComposition(
+    gameApi: GameApi,
+    playerData: PlayerData,
+    matchAwareness: MatchAwareness,
+): UnitComposition {
+    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<AttackFailReason> {
+    private squad: CombatSquad;
+
     private lastTargetSeenAt = 0;
-    private behaviour: CombatSquad | undefined;
     private hasPickedNewTarget: boolean = false;
 
+    private state: AttackMissionState = AttackMissionState.Preparing;
+
     constructor(
         uniqueName: string,
-        priority: number,
-        private rallyArea: Vector2,
+        private priority: number,
+        rallyArea: Vector2,
         private attackArea: Vector2,
         private radius: number,
+        private composition: UnitComposition,
         logger: DebugLogger,
     ) {
-        super(uniqueName, priority, logger);
+        super(uniqueName, logger);
+        this.squad = new CombatSquad(rallyArea, attackArea, radius);
+    }
+
+    _onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ): MissionAction {
+        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);
+        }
     }
 
-    onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
-        if (this.getSquad() === null) {
-            this.behaviour = new CombatSquad(this.rallyArea, this.attackArea, this.radius);
-            return this.setSquad(new Squad(this.getUniqueName(), this.behaviour, this));
+    private handlePreparingState(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ) {
+        const currentComposition: UnitComposition = 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 {
-            // Dispatch missions.
-            if (!matchAwareness.shouldAttack()) {
-                return disbandMission(AttackFailReason.DefenceTooStrong);
-            }
+            this.priority = ATTACK_MISSION_INITIAL_PRIORITY;
+            this.state = AttackMissionState.Attacking;
+            return noop();
+        }
+    }
 
-            const foundTargets = matchAwareness.getHostilesNearPoint2d(this.attackArea, this.radius);
-
-            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.behaviour?.setAttackArea(newTarget);
-                    this.hasPickedNewTarget = true;
-                }
+    private handleAttackingState(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: 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)) as UnitData[];
+
+        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();
     }
+
+    private handleRetreatingState(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ) {
+        this.getUnits(gameApi).forEach((unitId) => {
+            actionBatcher.push(manageMoveMicro(unitId, matchAwareness.getMainRallyPoint()));
+        });
+        return disbandMission();
+    }
+
+    public getGlobalDebugText(): string | undefined {
+        return this.squad.getGlobalDebugText() ?? "<none>";
+    }
+
+    public getState() {
+        return this.state;
+    }
+
+    // This mission can give up its units while preparing.
+    public isUnitsLocked(): boolean {
+        return this.state !== AttackMissionState.Preparing;
+    }
+
+    public getPriority() {
+        return this.priority;
+    }
 }
 
 // Calculates the weight for initiating an attack on the position of a unit or building.
@@ -89,7 +214,7 @@ function generateTarget(
     try {
         const tryFocusHarvester = gameApi.generateRandomInt(0, 1) === 0;
         const enemyUnits = gameApi
-            .getVisibleUnits(playerData.name, "hostile")
+            .getVisibleUnits(playerData.name, "enemy")
             .map((unitId) => gameApi.getUnitData(unitId))
             .filter((u) => !!u && gameApi.getPlayerData(u.owner).isCombatant) as UnitData[];
 
@@ -129,6 +254,8 @@ 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 implements MissionFactory {
     constructor(private lastAttackAt: number = -VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS) {}
 
@@ -143,14 +270,23 @@ export class AttackMissionFactory implements MissionFactory {
         missionController: MissionController,
         logger: DebugLogger,
     ): void {
-        if (!matchAwareness.shouldAttack()) {
+        if (gameApi.getCurrentTick() < this.lastAttackAt + VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS) {
             return;
         }
-        if (gameApi.getCurrentTick() < this.lastAttackAt + VISIBLE_TARGET_ATTACK_COOLDOWN_TICKS) {
+
+        // can only have one attack 'preparing' at once.
+        if (
+            missionController
+                .getMissions()
+                .some(
+                    (mission): mission is AttackMission =>
+                        mission instanceof AttackMission && mission.getState() === AttackMissionState.Preparing,
+                )
+        ) {
             return;
         }
 
-        const attackRadius = 15;
+        const attackRadius = 10;
 
         const includeEnemyBases = gameApi.getCurrentTick() > this.lastAttackAt + BASE_ATTACK_COOLDOWN_TICKS;
 
@@ -160,24 +296,25 @@ export class AttackMissionFactory implements MissionFactory {
             return;
         }
 
-        // TODO: not using a fixed value here. But performance slows to a crawl when this is unique.
-        const squadName = "globalAttack";
+        const squadName = "attack_" + gameApi.getCurrentTick();
+
+        const composition: UnitComposition = calculateTargetComposition(gameApi, playerData, matchAwareness);
 
         const tryAttack = missionController.addMission(
             new AttackMission(
                 squadName,
-                100,
+                ATTACK_MISSION_INITIAL_PRIORITY,
                 matchAwareness.getMainRallyPoint(),
                 attackArea,
                 attackRadius,
+                composition,
                 logger,
-            ).then((reason, squad) => {
+            ).then((unitIds, reason) => {
                 missionController.addMission(
                     new RetreatMission(
                         "retreat-from-" + squadName + gameApi.getCurrentTick(),
-                        100,
                         matchAwareness.getMainRallyPoint(),
-                        squad?.getUnitIds() ?? [],
+                        unitIds,
                         logger,
                     ),
                 );
@@ -192,7 +329,7 @@ export class AttackMissionFactory implements MissionFactory {
         gameApi: GameApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
-        failedMission: Mission,
+        failedMission: Mission<any>,
         failureReason: any,
         missionController: MissionController,
     ): void {}

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

@@ -1,55 +1,88 @@
-import { GameApi, PlayerData, Vector2 } from "@chronodivide/game-api";
+import { ActionsApi, GameApi, PlayerData, UnitData, Vector2 } from "@chronodivide/game-api";
 import { MatchAwareness } from "../../awareness.js";
 import { MissionController } from "../missionController.js";
-import { Mission, MissionAction, disbandMission, noop } from "../mission.js";
+import { Mission, MissionAction, grabCombatants, noop, releaseUnits, requestUnits } from "../mission.js";
 import { MissionFactory } from "../missionFactories.js";
-import { Squad } from "../../squad/squad.js";
-import { CombatSquad } from "../../squad/behaviours/combatSquad.js";
-import { RetreatMission } from "./retreatMission.js";
-import { DebugLogger } from "../../common/utils.js";
+import { CombatSquad } from "./squads/combatSquad.js";
+import { DebugLogger, isOwnedByNeutral } from "../../common/utils.js";
+import { ActionBatcher } from "../actionBatcher.js";
 
-export enum DefenceFailReason {
-    NoTargets,
-}
+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<DefenceFailReason> {
-    private combatSquad?: CombatSquad;
+export class DefenceMission extends Mission<CombatSquad> {
+    private squad: CombatSquad;
 
     constructor(
         uniqueName: string,
-        priority: number,
+        private priority: number,
+        rallyArea: Vector2,
         private defenceArea: Vector2,
         private radius: number,
         logger: DebugLogger,
     ) {
-        super(uniqueName, priority, logger);
+        super(uniqueName, logger);
+        this.squad = new CombatSquad(rallyArea, defenceArea, radius);
     }
 
-    onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction {
-        if (this.getSquad() === null && !this.combatSquad) {
-            this.combatSquad = new CombatSquad(matchAwareness.getMainRallyPoint(), this.defenceArea, this.radius);
-            return this.setSquad(new Squad("defenceSquad-" + this.getUniqueName(), this.combatSquad, this));
-        } else {
-            // Dispatch missions.
-            const foundTargets = matchAwareness.getHostilesNearPoint2d(this.defenceArea, this.radius);
+    _onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ): MissionAction {
+        // Dispatch missions.
+        const foundTargets = matchAwareness
+            .getHostilesNearPoint2d(this.defenceArea, this.radius)
+            .map((unit) => gameApi.getUnitData(unit.unitId))
+            .filter((unit) => !isOwnedByNeutral(unit)) as UnitData[];
+
+        const update = this.squad.onAiUpdate(
+            gameApi,
+            actionsApi,
+            actionBatcher,
+            playerData,
+            this,
+            matchAwareness,
+            this.logger,
+        );
+
+        if (update.type !== "noop") {
+            return update;
+        }
 
-            if (foundTargets.length === 0) {
-                this.logger(`(Defence Mission ${this.getUniqueName()}): No targets found, disbanding.`);
-                return disbandMission(DefenceFailReason.NoTargets);
+        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 {
-                const targetUnit = gameApi.getUnitData(foundTargets[0].unitId);
-                this.logger(
-                    `(Defence Mission ${this.getUniqueName()}): Focused on target ${targetUnit?.name} (${
-                        foundTargets.length
-                    } found in area ${this.radius})`,
-                );
-                this.combatSquad?.setAttackArea(new Vector2(foundTargets[0].x, foundTargets[0].y));
+                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 noop();
+        //return requestUnits(["E1", "E2", "FV", "HTK", "MTNK", "HTNK"], this.priority);
+    }
+
+    public getGlobalDebugText(): string | undefined {
+        return this.squad.getGlobalDebugText() ?? "<none>";
+    }
+
+    public getPriority() {
+        return this.priority;
     }
 }
 
@@ -83,7 +116,10 @@ export class DefenceMissionFactory implements MissionFactory {
 
         const defendableRadius =
             DEFENCE_STARTING_RADIUS + DEFENCE_RADIUS_INCREASE_PER_GAME_TICK * gameApi.getCurrentTick();
-        const enemiesNearSpawn = matchAwareness.getHostilesNearPoint2d(playerData.startLocation, defendableRadius);
+        const enemiesNearSpawn = matchAwareness
+            .getHostilesNearPoint2d(playerData.startLocation, defendableRadius)
+            .map((unit) => gameApi.getUnitData(unit.unitId))
+            .filter((unit) => !isOwnedByNeutral(unit)) as UnitData[];
 
         if (enemiesNearSpawn.length > 0) {
             logger(
@@ -94,21 +130,12 @@ export class DefenceMissionFactory implements MissionFactory {
             missionController.addMission(
                 new DefenceMission(
                     "globalDefence",
-                    1000,
+                    10,
+                    matchAwareness.getMainRallyPoint(),
                     playerData.startLocation,
                     defendableRadius * 1.2,
                     logger,
-                ).then((reason, squad) => {
-                    missionController.addMission(
-                        new RetreatMission(
-                            "retreat-from-globalDefence" + gameApi.getCurrentTick(),
-                            100,
-                            matchAwareness.getMainRallyPoint(),
-                            squad?.getUnitIds() ?? [],
-                            logger,
-                        ),
-                    );
-                }),
+                ),
             );
         }
     }
@@ -117,7 +144,7 @@ export class DefenceMissionFactory implements MissionFactory {
         gameApi: GameApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
-        failedMission: Mission,
+        failedMission: Mission<any>,
         failureReason: undefined,
         missionController: MissionController,
     ): void {}

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

@@ -1,21 +1,70 @@
-import { GameApi, PlayerData } from "@chronodivide/game-api";
-import { GlobalThreat } from "../../threat/threat.js";
-import { Mission } from "../mission.js";
-import { ExpansionSquad } from "../../squad/behaviours/expansionSquad.js";
+import { ActionsApi, GameApi, OrderType, PlayerData } from "@chronodivide/game-api";
+import { Mission, MissionAction, disbandMission, noop, requestUnits } from "../mission.js";
 import { MissionFactory } from "../missionFactories.js";
-import { OneTimeMission } from "./oneTimeMission.js";
 import { MatchAwareness } from "../../awareness.js";
 import { MissionController } from "../missionController.js";
 import { DebugLogger } from "../../common/utils.js";
-import { EngineerSquad } from "../../squad/behaviours/engineerSquad.js";
+import { ActionBatcher } from "../actionBatcher.js";
+
+const CAPTURE_COOLDOWN_TICKS = 30;
 
 /**
  * A mission that tries to send an engineer into a building (e.g. to capture tech building or repair bridge)
  */
-export class EngineerMission extends OneTimeMission {
-    constructor(uniqueName: string, priority: number, selectedTechBuilding: number, 
-        logger: DebugLogger) {
-        super(uniqueName, priority, () => new EngineerSquad(selectedTechBuilding), logger);
+export class EngineerMission extends Mission {
+    private hasAttemptedCaptureWith: {
+        unitId: number;
+        gameTick: number;
+    } | null = null;
+
+    constructor(
+        uniqueName: string,
+        private priority: number,
+        private captureTargetId: number,
+        logger: DebugLogger,
+    ) {
+        super(uniqueName, logger);
+    }
+
+    public _onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ): MissionAction {
+        const engineerTypes = ["ENGINEER", "SENGINEER"];
+        const engineers = this.getUnitsOfTypes(gameApi, ...engineerTypes);
+        if (engineers.length === 0) {
+            // Perhaps we deployed already (or the unit was destroyed), end the mission.
+            if (this.hasAttemptedCaptureWith !== null) {
+                return disbandMission();
+            }
+            return requestUnits(engineerTypes, this.priority);
+        } else if (
+            !this.hasAttemptedCaptureWith ||
+            gameApi.getCurrentTick() > this.hasAttemptedCaptureWith.gameTick + CAPTURE_COOLDOWN_TICKS
+        ) {
+            actionsApi.orderUnits(
+                engineers.map((engineer) => engineer.id),
+                OrderType.Capture,
+                this.captureTargetId,
+            );
+            // Add a cooldown to deploy attempts.
+            this.hasAttemptedCaptureWith = {
+                unitId: engineers[0].id,
+                gameTick: gameApi.getCurrentTick(),
+            };
+        }
+        return noop();
+    }
+
+    public getGlobalDebugText(): string | undefined {
+        return undefined;
+    }
+
+    public getPriority() {
+        return this.priority;
     }
 }
 
@@ -36,13 +85,17 @@ export class EngineerMissionFactory implements MissionFactory {
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
         missionController: MissionController,
-        logger: DebugLogger
+        logger: DebugLogger,
     ): void {
         if (!(gameApi.getCurrentTick() > this.lastCheckAt + TECH_CHECK_INTERVAL_TICKS)) {
             return;
         }
         this.lastCheckAt = gameApi.getCurrentTick();
-        const eligibleTechBuildings = gameApi.getVisibleUnits(playerData.name, "hostile", (r) => r.capturable && r.produceCashAmount > 0);
+        const eligibleTechBuildings = gameApi.getVisibleUnits(
+            playerData.name,
+            "hostile",
+            (r) => r.capturable && r.produceCashAmount > 0,
+        );
 
         eligibleTechBuildings.forEach((techBuildingId) => {
             missionController.addMission(new EngineerMission("capture-" + techBuildingId, 100, techBuildingId, logger));
@@ -53,9 +106,8 @@ export class EngineerMissionFactory implements MissionFactory {
         gameApi: GameApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
-        failedMission: Mission,
+        failedMission: Mission<any>,
         failureReason: undefined,
         missionController: MissionController,
-    ): void {
-    }
+    ): void {}
 }