@supalosa/chronodivide-bot 0.3.1 → 0.5.1

package/src/bot/logic/building/queueController.ts

@@ -14,6 +14,7 @@ import {
     DEFAULT_BUILDING_PRIORITY,
     getDefaultPlacementLocation,
 } from "./buildingRules.js";
+import { DebugLogger } from "../common/utils";
 
 export const QUEUES = [
     QueueType.Structures,
@@ -43,9 +44,16 @@ export const queueTypeToName = (queue: QueueType) => {
     }
 };
 
-const DEBUG_BUILD_QUEUES = true;
+type QueueState = {
+    queue: QueueType;
+    /** sorted in ascending order (last item is the topItem) */
+    items: TechnoRulesWithPriority[];
+    topItem: TechnoRulesWithPriority | undefined;
+};
 
 export class QueueController {
+    private queueStates: QueueState[] = [];
+
     constructor() {}
 
     public onAiUpdate(
@@ -54,23 +62,35 @@ export class QueueController {
         actionsApi: ActionsApi,
         playerData: PlayerData,
         threatCache: GlobalThreat | null,
+        unitTypeRequests: Map<string, number>,
         logger: (message: string) => void,
     ) {
-        const decisions = QUEUES.map((queueType) => {
+        this.queueStates = QUEUES.map((queueType) => {
             const options = productionApi.getAvailableObjects(queueType);
+            const items = this.getPrioritiesForBuildingOptions(
+                game,
+                options,
+                threatCache,
+                playerData,
+                unitTypeRequests,
+                logger,
+            );
+            const topItem = items.length > 0 ? items[items.length - 1] : undefined;
             return {
                 queue: queueType,
-                decision: this.getBestOptionForBuilding(game, options, threatCache, playerData, logger),
+                items,
+                // only if the top item has a  priority above zero
+                topItem: topItem && topItem.priority > 0 ? topItem : undefined,
             };
-        }).filter((decision) => decision.decision != null);
-        let totalWeightAcrossQueues = decisions
-            .map((decision) => decision.decision?.priority!)
+        });
+        const totalWeightAcrossQueues = this.queueStates
+            .map((decision) => decision.topItem?.priority!)
             .reduce((pV, cV) => pV + cV, 0);
-        let totalCostAcrossQueues = decisions
-            .map((decision) => decision.decision?.unit.cost!)
+        const totalCostAcrossQueues = this.queueStates
+            .map((decision) => decision.topItem?.unit.cost!)
             .reduce((pV, cV) => pV + cV, 0);
 
-        decisions.forEach((decision) => {
+        this.queueStates.forEach((decision) => {
             this.updateBuildQueue(
                 game,
                 productionApi,
@@ -78,7 +98,7 @@ export class QueueController {
                 playerData,
                 threatCache,
                 decision.queue,
-                decision.decision,
+                decision.topItem,
                 totalWeightAcrossQueues,
                 totalCostAcrossQueues,
                 logger,
@@ -86,13 +106,17 @@ export class QueueController {
         });
 
         // Repair is simple - just repair everything that's damaged.
-        game.getVisibleUnits(playerData.name, "self", (r) => r.repairable).forEach((unitId) => {
-            const unit = game.getUnitData(unitId);
-            if (!unit || !unit.hitPoints || !unit.maxHitPoints || unit.hasWrenchRepair) {
-                return;
-            }
-            actionsApi.toggleRepairWrench(unitId);
-        });
+        if (playerData.credits > 0) {
+            game.getVisibleUnits(playerData.name, "self", (r) => r.repairable).forEach((unitId) => {
+                const unit = game.getUnitData(unitId);
+                if (!unit || !unit.hitPoints || !unit.maxHitPoints || unit.hasWrenchRepair) {
+                    return;
+                }
+                if (unit.hitPoints < unit.maxHitPoints) {
+                    actionsApi.toggleRepairWrench(unitId);
+                }
+            });
+        }
     }
 
     private updateBuildQueue(
@@ -120,31 +144,41 @@ export class QueueController {
             // Consider placing it.
             const objectReady: TechnoRules = queueData.items[0].rules;
             if (queueType == QueueType.Structures || queueType == QueueType.Armory) {
-                logger(`Complete ${queueTypeToName(queueType)}: ${objectReady.name}`);
                 let location: { rx: number; ry: number } | undefined = this.getBestLocationForStructure(
                     game,
                     playerData,
                     objectReady,
                 );
                 if (location !== undefined) {
+                    logger(
+                        `Completed: ${queueTypeToName(queueType)}: ${objectReady.name}, placing at ${location.rx},${
+                            location.ry
+                        }`,
+                    );
                     actionsApi.placeBuilding(objectReady.name, location.rx, location.ry);
+                } else {
+                    logger(`Completed: ${queueTypeToName(queueType)}: ${objectReady.name} but nowhere to place it`);
                 }
             }
         } else if (queueData.status == QueueStatus.Active && queueData.items.length > 0 && decision != null) {
-            // Consider cancelling if something else is significantly higher priority.
-            const current = queueData.items[0].rules;
-            const options = productionApi.getAvailableObjects(queueType);
-            if (decision.unit != current) {
+            // Consider cancelling if something else is significantly higher priority than what is currently being produced.
+            const currentProduction = queueData.items[0].rules;
+            if (decision.unit != currentProduction) {
                 // Changing our mind.
-                let currentItemPriority = this.getPriorityForBuildingOption(current, game, playerData, threatCache);
+                let currentItemPriority = this.getPriorityForBuildingOption(
+                    currentProduction,
+                    game,
+                    playerData,
+                    threatCache,
+                );
                 let newItemPriority = decision.priority;
                 if (newItemPriority > currentItemPriority * 2) {
                     logger(
-                        `Dequeueing queue ${queueTypeToName(queueData.type)} unit ${current.name} because ${
+                        `Dequeueing queue ${queueTypeToName(queueData.type)} unit ${currentProduction.name} because ${
                             decision.unit.name
                         } has 2x higher priority.`,
                     );
-                    actionsApi.unqueueFromProduction(queueData.type, current.name, current.type, 1);
+                    actionsApi.unqueueFromProduction(queueData.type, currentProduction.name, currentProduction.type, 1);
                 }
             } else {
                 // Not changing our mind, but maybe other queues are more important for now.
@@ -173,32 +207,29 @@ export class QueueController {
         }
     }
 
-    private getBestOptionForBuilding(
+    private getPrioritiesForBuildingOptions(
         game: GameApi,
         options: TechnoRules[],
         threatCache: GlobalThreat | null,
         playerData: PlayerData,
-        logger: (message: string) => void,
-    ): TechnoRulesWithPriority | undefined {
+        unitTypeRequests: Map<string, number>,
+        logger: DebugLogger,
+    ): TechnoRulesWithPriority[] {
         let priorityQueue: TechnoRulesWithPriority[] = [];
         options.forEach((option) => {
-            let priority = this.getPriorityForBuildingOption(option, game, playerData, threatCache);
-            if (priority > 0) {
-                priorityQueue.push({ unit: option, priority: priority });
+            const calculatedPriority = this.getPriorityForBuildingOption(option, game, playerData, threatCache);
+            // Get the higher of the dynamic and the mission priority for the unit.
+            const actualPriority = Math.max(
+                calculatedPriority,
+                unitTypeRequests.get(option.name) ?? calculatedPriority,
+            );
+            if (actualPriority > 0) {
+                priorityQueue.push({ unit: option, priority: actualPriority });
             }
         });
 
-        priorityQueue = priorityQueue.sort((a, b) => {
-            return a.priority - b.priority;
-        });
-        if (priorityQueue.length > 0) {
-            if (DEBUG_BUILD_QUEUES && game.getCurrentTick() % 100 === 0) {
-                let queueString = priorityQueue.map((item) => item.unit.name + "(" + item.priority + ")").join(", ");
-                logger(`Build priority currently: ${queueString}`);
-            }
-        }
-
-        return priorityQueue.pop();
+        priorityQueue = priorityQueue.sort((a, b) => a.priority - b.priority);
+        return priorityQueue;
     }
 
     private getPriorityForBuildingOption(
@@ -231,4 +262,36 @@ export class QueueController {
             return getDefaultPlacementLocation(game, playerData, playerData.startLocation, objectReady);
         }
     }
+
+    public getGlobalDebugText(gameApi: GameApi, productionApi: ProductionApi) {
+        const productionState = QUEUES.reduce((prev, queueType) => {
+            if (productionApi.getQueueData(queueType).size === 0) {
+                return prev;
+            }
+            const paused = productionApi.getQueueData(queueType).status === QueueStatus.OnHold;
+            return (
+                prev +
+                " [" +
+                queueTypeToName(queueType) +
+                (paused ? " PAUSED" : "") +
+                ": " +
+                productionApi
+                    .getQueueData(queueType)
+                    .items.map((item) => item.rules.name + (item.quantity > 1 ? "x" + item.quantity : "")) +
+                "]"
+            );
+        }, "");
+
+        const queueStates = this.queueStates
+            .filter((queueState) => queueState.items.length > 0)
+            .map((queueState) => {
+                const queueString = queueState.items
+                    .map((item) => item.unit.name + "(" + Math.round(item.priority * 10) / 10 + ")")
+                    .join(", ");
+                return `${queueTypeToName(queueState.queue)} Prios: ${queueString}\n`;
+            })
+            .join("");
+
+        return `Production: ${productionState}\n${queueStates}`;
+    }
 }

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);
@@ -16,6 +29,23 @@ export function pad(n: any, format = "0000") {
     return format.substring(0, format.length - str.length) + str;
 }
 
+// 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) {
         return null;
@@ -63,3 +93,20 @@ export function countBy<T>(array: T[], predicate: (arg: T) => string | undefined
         {} as Record<string, number>,
     );
 }
+
+export function groupBy<K extends string, V>(array: V[], predicate: (arg: V) => K): { [key in K]: V[] } {
+    return array.reduce(
+        (prev, newVal) => {
+            const val = predicate(newVal);
+            if (val === undefined) {
+                return prev;
+            }
+            if (!prev.hasOwnProperty(val)) {
+                prev[val] = [];
+            }
+            prev[val].push(newVal);
+            return prev;
+        },
+        {} as Record<K, V[]>,
+    );
+}

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/mission/actionBatcher.ts

@@ -0,0 +1,124 @@
+// 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";
+
+// are ordered to move to the same location, all of them will be ordered to move in a single action.
+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[];
+
+    constructor() {
+        this.actions = [];
+    }
+
+    push(action: BatchableAction) {
+        this.actions.push(action);
+    }
+
+    resolve(actionsApi: ActionsApi) {
+        const groupedCommands = groupBy(this.actions, (action) => action.orderType.valueOf().toString());
+        const vectorToStr = (v: Vector2) => v.x + "," + v.y;
+        const strToVector = (str: string) => {
+            const [x, y] = str.split(",");
+            return new Vector2(parseInt(x), parseInt(y));
+        };
+
+        // Group by command type.
+        Object.entries(groupedCommands).forEach(([commandValue, commands]) => {
+            // i hate this
+            const commandType: OrderType = parseInt(commandValue) as OrderType;
+            // Group by command target ID.
+            const byTarget = groupBy(
+                commands.filter((command) => !!command.targetId),
+                (command) => command.targetId?.toString()!,
+            );
+            Object.entries(byTarget).forEach(([targetId, unitCommands]) => {
+                actionsApi.orderUnits(
+                    unitCommands.map((command) => command.unitId),
+                    commandType,
+                    parseInt(targetId),
+                );
+            });
+            // Group by position (the vector is encoded as a string of the form "x,y")
+            const byPosition = groupBy(
+                commands.filter((command) => !!command.point),
+                (command) => vectorToStr(command.point!),
+            );
+            Object.entries(byPosition).forEach(([point, unitCommands]) => {
+                const vector = strToVector(point);
+                actionsApi.orderUnits(
+                    unitCommands.map((command) => command.unitId),
+                    commandType,
+                    vector.x,
+                    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,
+                );
+            }
+        });
+    }
+}