@supalosa/chronodivide-bot 0.4.0 → 0.5.2

package/src/bot/logic/common/utils.ts

@@ -1,5 +1,18 @@
+import { GameObjectData, TechnoRules, UnitData } from "@chronodivide/game-api";
+
 export type DebugLogger = (message: string, sayInGame?: boolean) => void;
 
+const SOVIET_COUNTRY_NAMES = ["Africans", "Arabs", "Confederation", "Russians"];
+
+export const isSoviet = (countryName: string) => SOVIET_COUNTRY_NAMES.includes(countryName);
+
+export const isOwnedByNeutral = (unitData: UnitData | undefined) => unitData?.owner === "@@NEUTRAL@@";
+
+// Return if the given unit would have .isSelectableCombatant = true.
+// Usable on GameObjectData (which is faster to get than TechnoRules)
+export const isSelectableCombatant = (rules: GameObjectData | undefined) =>
+    !!(rules?.rules as any)?.isSelectableCombatant;
+
 // Thanks use-strict!
 export function formatTimeDuration(timeSeconds: number, skipZeroHours = false) {
     let h = Math.floor(timeSeconds / 3600);
@@ -17,6 +30,21 @@ export function pad(n: any, format = "0000") {
 }
 
 // So we don't need lodash
+export function minBy<T>(array: T[], predicate: (arg: T) => number | null): T | null {
+    if (array.length === 0) {
+        return null;
+    }
+    let minIdx = 0;
+    let minVal = predicate(array[0]);
+    for (let i = 1; i < array.length; ++i) {
+        const newVal = predicate(array[i]);
+        if (minVal === null || (newVal !== null && newVal < minVal)) {
+            minIdx = i;
+            minVal = newVal;
+        }
+    }
+    return array[minIdx];
+}
 
 export function maxBy<T>(array: T[], predicate: (arg: T) => number | null): T | null {
     if (array.length === 0) {

package/src/bot/logic/composition/alliedCompositions.ts

@@ -0,0 +1,22 @@
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { MatchAwareness } from "../awareness";
+import { UnitComposition } from "./common";
+
+export const getAlliedCompositions = (
+    gameApi: GameApi,
+    playerData: PlayerData,
+    matchAwareness: MatchAwareness,
+): UnitComposition => {
+    const hasWarFactory = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "GAWEAP").length > 0;
+    const hasAirforce =
+        gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "GAAIRC" || r.name === "AMRADR").length > 0;
+    const hasBattleLab = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "GATECH").length > 0;
+
+    const includeInfantry = !hasAirforce && !hasBattleLab;
+    return {
+        ...(includeInfantry && { E1: 5 }),
+        ...(hasWarFactory && { MTNK: 3, FV: 2 }),
+        ...(hasAirforce && { JUMPJET: 6 }),
+        ...(hasBattleLab && { SREF: 2, MGTK: 3 }),
+    };
+};

package/src/bot/logic/composition/common.ts

@@ -0,0 +1,3 @@
+export type UnitComposition = {
+    [unitType: string]: number;
+};

package/src/bot/logic/composition/sovietCompositions.ts

@@ -0,0 +1,21 @@
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { MatchAwareness } from "../awareness";
+import { UnitComposition } from "./common";
+
+export const getSovietComposition = (
+    gameApi: GameApi,
+    playerData: PlayerData,
+    matchAwareness: MatchAwareness,
+): UnitComposition => {
+    const hasWarFactory = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "NAWEAP").length > 0;
+    const hasRadar = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "NARADR").length > 0;
+    const hasBattleLab = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "NATECH").length > 0;
+
+    const includeInfantry = !hasBattleLab;
+    return {
+        ...(includeInfantry && { E2: 10 }),
+        ...(hasWarFactory && { HTNK: 3, HTK: 2 }),
+        ...(hasRadar && { V3: 1 }),
+        ...(hasBattleLab && { APOC: 2 }),
+    };
+};

package/src/bot/logic/{squad/behaviours → mission}/actionBatcher.ts

@@ -1,15 +1,66 @@
 // Used to group related actions together to minimise actionApi calls. For example, if multiple units
 
 import { ActionsApi, OrderType, Vector2 } from "@chronodivide/game-api";
-import { groupBy } from "../../common/utils.js";
+import { groupBy } from "../common/utils.js";
 
 // are ordered to move to the same location, all of them will be ordered to move in a single action.
-export type BatchableAction = {
-    unitId: number;
-    orderType: OrderType;
-    point?: Vector2;
-    targetId?: number;
-};
+export class BatchableAction {
+    private constructor(
+        private _unitId: number,
+        private _orderType: OrderType,
+        private _point?: Vector2,
+        private _targetId?: number,
+        // If you don't want this action to be swallowed by dedupe, provide a unique nonce
+        private _nonce: number = 0,
+    ) {}
+
+    static noTarget(unitId: number, orderType: OrderType, nonce: number = 0) {
+        return new BatchableAction(unitId, orderType, undefined, undefined, nonce);
+    }
+
+    static toPoint(unitId: number, orderType: OrderType, point: Vector2, nonce: number = 0) {
+        return new BatchableAction(unitId, orderType, point, undefined);
+    }
+
+    static toTargetId(unitId: number, orderType: OrderType, targetId: number, nonce: number = 0) {
+        return new BatchableAction(unitId, orderType, undefined, targetId, nonce);
+    }
+
+    public get unitId() {
+        return this._unitId;
+    }
+
+    public get orderType() {
+        return this._orderType;
+    }
+
+    public get point() {
+        return this._point;
+    }
+
+    public get targetId() {
+        return this._targetId;
+    }
+
+    public isSameAs(other: BatchableAction) {
+        if (this._unitId !== other._unitId) {
+            return false;
+        }
+        if (this._orderType !== other._orderType) {
+            return false;
+        }
+        if (this._point !== other._point) {
+            return false;
+        }
+        if (this._targetId !== other._targetId) {
+            return false;
+        }
+        if (this._nonce !== other._nonce) {
+            return false;
+        }
+        return true;
+    }
+}
 
 export class ActionBatcher {
     private actions: BatchableAction[];
@@ -60,6 +111,14 @@ export class ActionBatcher {
                     vector.y,
                 );
             });
+            // Actions with no targets
+            const noTargets = commands.filter((command) => !command.targetId && !command.point);
+            if (noTargets.length > 0) {
+                actionsApi.orderUnits(
+                    noTargets.map((action) => action.unitId),
+                    commandType,
+                );
+            }
         });
     }
 }

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

@@ -1,36 +1,127 @@
-import { GameApi, PlayerData } from "@chronodivide/game-api";
-import { Squad } from "../squad/squad.js";
+import { ActionsApi, GameApi, PlayerData, Tile, UnitData, Vector2 } from "@chronodivide/game-api";
 import { MatchAwareness } from "../awareness.js";
 import { DebugLogger } from "../common/utils.js";
-
-// AI starts Missions based on heuristics, which have one or more squads.
-// Missions can create squads (but squads will disband themselves).
+import { ActionBatcher } from "./actionBatcher.js";
+import { getDistanceBetweenTileAndPoint } from "../map/map.js";
+
+const calculateCenterOfMass: (unitTiles: Tile[]) => {
+    centerOfMass: Vector2;
+    maxDistance: number;
+} | null = (unitTiles) => {
+    if (unitTiles.length === 0) {
+        return null;
+    }
+    // TODO: use median here
+    const sums = unitTiles.reduce(
+        ({ x, y }, tile) => {
+            return {
+                x: x + (tile?.rx || 0),
+                y: y + (tile?.ry || 0),
+            };
+        },
+        { x: 0, y: 0 },
+    );
+    const centerOfMass = new Vector2(Math.round(sums.x / unitTiles.length), Math.round(sums.y / unitTiles.length));
+
+    // max distance of units to the center of mass
+    const distances = unitTiles.map((tile) => getDistanceBetweenTileAndPoint(tile, centerOfMass));
+    const maxDistance = Math.max(...distances);
+    return { centerOfMass, maxDistance };
+};
+// AI starts Missions based on heuristics.
 export abstract class Mission<FailureReasons = undefined> {
-    private squad: Squad | null = null;
     private active = true;
+    private unitIds: number[] = [];
+    private centerOfMass: Vector2 | null = null;
+    private maxDistanceToCenterOfMass: number | null = null;
+
+    private onFinish: (unitIds: number[], reason: FailureReasons) => void = () => {};
+
+    constructor(
+        private uniqueName: string,
+        protected logger: DebugLogger,
+    ) {}
+
+    // TODO call this
+    protected updateCenterOfMass(gameApi: GameApi) {
+        const movableUnitTiles = this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => unit?.canMove)
+            .map((unit) => unit?.tile)
+            .filter((tile) => !!tile) as Tile[];
+        const tileMetrics = calculateCenterOfMass(movableUnitTiles);
+        if (tileMetrics) {
+            this.centerOfMass = tileMetrics.centerOfMass;
+            this.maxDistanceToCenterOfMass = tileMetrics.maxDistance;
+        } else {
+            this.centerOfMass = null;
+            this.maxDistanceToCenterOfMass = null;
+        }
+    }
 
-    private onFinish: (reason: FailureReasons, squad: Squad | null) => void = () => {};
-
-    constructor(private uniqueName: string, private priority: number, protected logger: DebugLogger) {}
+    public onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ): MissionAction {
+        this.updateCenterOfMass(gameApi);
+        return this._onAiUpdate(gameApi, actionsApi, playerData, matchAwareness, actionBatcher);
+    }
 
-    abstract onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction;
+    // TODO: fix this weird indirection
+    abstract _onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        actionBatcher: ActionBatcher,
+    ): MissionAction;
 
     isActive(): boolean {
         return this.active;
     }
 
-    protected setSquad(squad: Squad): MissionActionRegisterSquad {
-        this.squad = squad;
-        return registerSquad(squad);
+    public getUnitIds(): number[] {
+        return this.unitIds;
+    }
+
+    public removeUnit(unitIdToRemove: number): void {
+        this.unitIds = this.unitIds.filter((unitId) => unitId != unitIdToRemove);
+    }
+
+    public addUnit(unitIdToAdd: number): void {
+        this.unitIds.push(unitIdToAdd);
     }
 
-    getSquad(): Squad | null {
-        return this.squad;
+    public getUnits(gameApi: GameApi): UnitData[] {
+        return this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => unit != null)
+            .map((unit) => unit!);
     }
 
-    removeSquad() {
-        // The squad was removed from this mission.
-        this.squad = null;
+    public getUnitsOfTypes(gameApi: GameApi, ...names: string[]): UnitData[] {
+        return this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => !!unit && names.includes(unit.name))
+            .map((unit) => unit!);
+    }
+
+    public getUnitsMatching(gameApi: GameApi, filter: (r: UnitData) => boolean): UnitData[] {
+        return this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => !!unit && filter(unit))
+            .map((unit) => unit!);
+    }
+
+    public getCenterOfMass() {
+        return this.centerOfMass;
+    }
+
+    public getMaxDistanceToCenterOfMass() {
+        return this.maxDistanceToCenterOfMass;
     }
 
     getUniqueName(): string {
@@ -39,27 +130,37 @@ export abstract class Mission<FailureReasons = undefined> {
 
     // Don't call this from the mission itself
     endMission(reason: FailureReasons): void {
-        this.onFinish(reason, this.squad);
-        this.squad = null;
+        this.onFinish(this.unitIds, reason);
         this.active = false;
     }
 
     /**
      * Declare a callback that is executed when the mission is disbanded for whatever reason.
      */
-    then(onFinish: (reason: FailureReasons, squad: Squad | null) => void): Mission<FailureReasons> {
+    then(onFinish: (unitIds: number[], reason: FailureReasons) => void): Mission<FailureReasons> {
         this.onFinish = onFinish;
         return this;
     }
+
+    abstract getGlobalDebugText(): string | undefined;
+
+    /**
+     * Determines whether units can be stolen from this mission by other missions with higher priority.
+     */
+    public isUnitsLocked(): boolean {
+        return true;
+    }
+
+    abstract getPriority(): number;
 }
 
-export type MissionActionNoop = {
-    type: "noop";
+export type MissionWithAction<T extends MissionAction> = {
+    mission: Mission<any>;
+    action: T;
 };
 
-export type MissionActionRegisterSquad = {
-    type: "registerSquad";
-    squad: Squad;
+export type MissionActionNoop = {
+    type: "noop";
 };
 
 export type MissionActionDisband = {
@@ -67,17 +168,65 @@ export type MissionActionDisband = {
     reason: any | null;
 };
 
-export const noop = () =>
-    ({
-        type: "noop",
-    } as MissionActionNoop);
+export type MissionActionRequestUnits = {
+    type: "request";
+    unitNames: string[];
+    priority: number;
+};
 
-export const registerSquad = (squad: Squad) =>
-    ({
-        type: "registerSquad",
-        squad,
-    } as MissionActionRegisterSquad);
+export type MissionActionRequestSpecificUnits = {
+    type: "requestSpecific";
+    unitIds: number[];
+    priority: number;
+};
 
-export const disbandMission = (reason?: any) => ({ type: "disband", reason } as MissionActionDisband);
+export type MissionActionGrabFreeCombatants = {
+    type: "requestCombatants";
+    point: Vector2;
+    radius: number;
+};
 
-export type MissionAction = MissionActionNoop | MissionActionRegisterSquad | MissionActionDisband;
+export type MissionActionReleaseUnits = {
+    type: "releaseUnits";
+    unitIds: number[];
+};
+
+export const noop = () =>
+    ({
+        type: "noop",
+    }) as MissionActionNoop;
+
+export const disbandMission = (reason?: any) => ({ type: "disband", reason }) as MissionActionDisband;
+export const isDisbandMission = (a: MissionWithAction<MissionAction>): a is MissionWithAction<MissionActionDisband> =>
+    a.action.type === "disband";
+
+export const requestUnits = (unitNames: string[], priority: number) =>
+    ({ type: "request", unitNames, priority }) as MissionActionRequestUnits;
+export const isRequestUnits = (
+    a: MissionWithAction<MissionAction>,
+): a is MissionWithAction<MissionActionRequestUnits> => a.action.type === "request";
+
+export const requestSpecificUnits = (unitIds: number[], priority: number) =>
+    ({ type: "requestSpecific", unitIds, priority }) as MissionActionRequestSpecificUnits;
+export const isRequestSpecificUnits = (
+    a: MissionWithAction<MissionAction>,
+): a is MissionWithAction<MissionActionRequestSpecificUnits> => a.action.type === "requestSpecific";
+
+export const grabCombatants = (point: Vector2, radius: number) =>
+    ({ type: "requestCombatants", point, radius }) as MissionActionGrabFreeCombatants;
+export const isGrabCombatants = (
+    a: MissionWithAction<MissionAction>,
+): a is MissionWithAction<MissionActionGrabFreeCombatants> => a.action.type === "requestCombatants";
+
+export const releaseUnits = (unitIds: number[]) => ({ type: "releaseUnits", unitIds }) as MissionActionReleaseUnits;
+export const isReleaseUnits = (
+    a: MissionWithAction<MissionAction>,
+): a is MissionWithAction<MissionActionReleaseUnits> => a.action.type === "releaseUnits";
+
+export type MissionAction =
+    | MissionActionNoop
+    | MissionActionDisband
+    | MissionActionRequestUnits
+    | MissionActionRequestSpecificUnits
+    | MissionActionGrabFreeCombatants
+    | MissionActionReleaseUnits;