@supalosa/chronodivide-bot 0.4.0 → 0.5.1

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

@@ -20,6 +20,7 @@ import { PowerPlant } from "./powerPlant.js";
 import { ResourceCollectionBuilding } from "./resourceCollectionBuilding.js";
 import { Harvester } from "./harvester.js";
 import { uniqBy } from "../common/utils.js";
+import { AntiAirStaticDefence } from "./antiAirStaticDefence.js";
 
 export interface AiBuildingRules {
     getPriority(
@@ -183,7 +184,7 @@ export function getDefaultPlacementLocation(
 // Priority 0 = don't build.
 export type TechnoRulesWithPriority = { unit: TechnoRules; priority: number };
 
-export const DEFAULT_BUILDING_PRIORITY = 1;
+export const DEFAULT_BUILDING_PRIORITY = 0;
 
 export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
     // Allied
@@ -192,7 +193,6 @@ export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
     ["GAWEAP", new BasicBuilding(15, 1)], // War Factory
     ["GAPILE", new BasicBuilding(12, 1)], // Barracks
     ["CMIN", new Harvester(15, 4, 2)], // Chrono Miner
-    ["ENGINEER", new BasicBuilding(10, 1, 1000)], // Engineer
     ["GADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
     ["GAAIRC", new BasicBuilding(10, 1, 500)], // Airforce Command
     ["AMRADR", new BasicBuilding(10, 1, 500)], // Airforce Command (USA)
@@ -200,11 +200,13 @@ export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
     ["GATECH", new BasicBuilding(20, 1, 4000)], // Allied Battle Lab
     ["GAYARD", new BasicBuilding(0, 0, 0)], // Naval Yard, disabled
 
-    ["GAPILL", new AntiGroundStaticDefence(5, 1, 5)], // Pillbox
-    ["ATESLA", new AntiGroundStaticDefence(5, 1, 10)], // Prism Cannon
+    ["GAPILL", new AntiGroundStaticDefence(2, 1, 5)], // Pillbox
+    ["ATESLA", new AntiGroundStaticDefence(2, 1, 10)], // Prism Cannon
+    ["NASAM", new AntiAirStaticDefence(2, 1, 5)], // Prism Cannon
     ["GAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
 
-    ["E1", new BasicGroundUnit(2, 3, 0.25, 0)], // GI
+    ["E1", new BasicGroundUnit(2, 2, 0.2, 0)], // GI
+    ["ENGINEER", new BasicGroundUnit(1, 0, 0)], // Engineer
     ["MTNK", new BasicGroundUnit(10, 3, 2, 0)], // Grizzly Tank
     ["MGTK", new BasicGroundUnit(10, 1, 2.5, 0)], // Mirage Tank
     ["FV", new BasicGroundUnit(5, 2, 0.5, 1)], // IFV
@@ -220,7 +222,6 @@ export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
     ["NAWEAP", new BasicBuilding(15, 1)], // War Factory
     ["NAHAND", new BasicBuilding(12, 1)], // Barracks
     ["HARV", new Harvester(15, 4, 2)], // War Miner
-    ["SENGINEER", new BasicBuilding(10, 1, 1000)], // Soviet Engineer
     ["NADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
     ["NARADR", new BasicBuilding(10, 1, 500)], // Radar
     ["NANRCT", new PowerPlant()], // Nuclear Reactor
@@ -228,11 +229,16 @@ export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
 
     ["NATECH", new BasicBuilding(20, 1, 4000)], // Soviet Battle Lab
 
-    ["NALASR", new AntiGroundStaticDefence(5, 1, 5)], // Sentry Gun
-    ["TESLA", new AntiGroundStaticDefence(5, 1, 10)], // Tesla Coil
+    ["NALASR", new AntiGroundStaticDefence(2, 1, 5)], // Sentry Gun
+    ["NAFLAK", new AntiAirStaticDefence(2, 1, 5)], // Flak Cannon
+    ["TESLA", new AntiGroundStaticDefence(2, 1, 10)], // Tesla Coil
     ["NAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
 
-    ["E2", new BasicGroundUnit(2, 3, 0.25, 0)], // Conscript
+    ["E2", new BasicGroundUnit(2, 2, 0.2, 0)], // Conscript
+    ["SENGINEER", new BasicGroundUnit(1, 0, 0)], // Soviet Engineer
+    ["FLAKT", new BasicGroundUnit(2, 2, 0.1, 0.3)], // Flak Trooper
+    ["YURI", new BasicGroundUnit(1, 1, 1, 0)], // Yuri
+    ["DOG", new BasicGroundUnit(1, 1, 0, 0)], // Soviet Attack Dog
     ["HTNK", new BasicGroundUnit(10, 3, 3, 0)], // Rhino Tank
     ["APOC", new BasicGroundUnit(6, 1, 5, 0)], // Apocalypse Tank
     ["HTK", new BasicGroundUnit(5, 2, 0.33, 1.5)], // Flak Track

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

@@ -0,0 +1,23 @@
+import { GameApi, PlayerData, TechnoRules, Vector2 } from "@chronodivide/game-api";
+import { getPointTowardsOtherPoint } from "../map/map.js";
+import { getDefaultPlacementLocation } from "./buildingRules.js";
+
+export const getStaticDefencePlacement = (game: GameApi, playerData: PlayerData, technoRules: TechnoRules) => {
+    // Prefer front towards enemy.
+    let startLocation = playerData.startLocation;
+    let players = game.getPlayers();
+    let enemyFacingLocationCandidates: Vector2[] = [];
+    for (let i = 0; i < players.length; ++i) {
+        let playerName = players[i];
+        if (playerName == playerData.name) {
+            continue;
+        }
+        let enemyPlayer = game.getPlayerData(playerName);
+        enemyFacingLocationCandidates.push(
+            getPointTowardsOtherPoint(game, startLocation, enemyPlayer.startLocation, 4, 16, 1.5),
+        );
+    }
+    let selectedLocation =
+        enemyFacingLocationCandidates[Math.floor(game.generateRandom() * enemyFacingLocationCandidates.length)];
+    return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules, false, 0);
+};

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

@@ -3,6 +3,7 @@ import { GlobalThreat } from "../threat/threat.js";
 import { BasicGroundUnit } from "./basicGroundUnit.js";
 
 const IDEAL_HARVESTERS_PER_REFINERY = 2;
+const MAX_HARVESTERS_PER_REFINERY = 4;
 
 export class Harvester extends BasicGroundUnit {
     constructor(
@@ -23,7 +24,7 @@ export class Harvester extends BasicGroundUnit {
         const refineries = game.getVisibleUnits(playerData.name, "self", (r) => r.refinery).length;
         const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
 
-        const boost = harvesters < this.minNeeded ? 3 : 1;
+        const boost = harvesters < this.minNeeded ? 3 : harvesters > refineries * MAX_HARVESTERS_PER_REFINERY ? 0 : 1;
 
         return this.basePriority * (refineries / Math.max(harvesters / IDEAL_HARVESTERS_PER_REFINERY, 1)) * boost;
     }

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,15 +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;
-            }
-            if (unit.hitPoints < unit.maxHitPoints) {
-                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(
@@ -139,20 +161,24 @@ export class QueueController {
                 }
             }
         } 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.
@@ -181,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(
@@ -239,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);
@@ -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,
+                );
+            }
         });
     }
 }