@supalosa/chronodivide-bot 0.1.0

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

@@ -0,0 +1,120 @@
+import { BuildingPlacementData, GameApi, PlayerData, Point2D, TechnoRules } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { AntiGroundStaticDefence } from "./antiGroundStaticDefence.js";
+import { ArtilleryUnit } from "./ArtilleryUnit.js";
+import { BasicAirUnit } from "./basicAirUnit.js";
+import { BasicBuilding } from "./basicBuilding.js";
+import { BasicGroundUnit } from "./basicGroundUnit.js";
+import { PowerPlant } from "./powerPlant.js";
+import { ResourceCollectionBuilding } from "./resourceCollectionBuilding.js";
+import { Harvester } from "./harvester.js";
+
+export interface AiBuildingRules {
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | undefined
+    ): number;
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules
+    ): { rx: number; ry: number } | undefined;
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | undefined
+    ): number | null;
+}
+
+export function numBuildingsOwnedOfType(game: GameApi, playerData: PlayerData, technoRules: TechnoRules): number {
+    return game.getVisibleUnits(playerData.name, "self", (r) => r == technoRules).length;
+}
+
+export function numBuildingsOwnedOfName(game: GameApi, playerData: PlayerData, name: string): number {
+    return game.getVisibleUnits(playerData.name, "self", (r) => r.name === name).length;
+}
+
+export function getDefaultPlacementLocation(
+    game: GameApi,
+    playerData: PlayerData,
+    startPoint: Point2D,
+    technoRules: TechnoRules,
+    space: number = 1
+): { rx: number; ry: number } | undefined {
+    // Random location, preferably near start location.
+    let startX = startPoint.x;
+    let startY = startPoint.y;
+    let size: BuildingPlacementData = game.getBuildingPlacementData(technoRules.name);
+    if (!size) {
+        return undefined;
+    }
+    let largestSize = Math.max(size.foundation.height, size.foundation.width);
+    for (let searchRadius = largestSize; searchRadius < 25 + largestSize; ++searchRadius) {
+        for (let xx = startX - searchRadius; xx < startX + searchRadius; ++xx) {
+            for (let yy = startY - searchRadius; yy < startY + searchRadius; ++yy) {
+                let tile = game.mapApi.getTile(xx, yy);
+                if (tile && game.canPlaceBuilding(playerData.name, technoRules.name, tile)) {
+                    return { rx: xx, ry: yy };
+                }
+            }
+        }
+    }
+    console.log("Can't find a place to put the " + technoRules.name);
+    return undefined;
+}
+
+// Priority 0 = don't build.
+export type TechnoRulesWithPriority = { unit: TechnoRules; priority: number };
+
+export const DEFAULT_BUILDING_PRIORITY = 1;
+
+export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
+    // Allied
+    ["GAPOWR", new PowerPlant()],
+    ["GAREFN", new ResourceCollectionBuilding(10, 3)], // Refinery
+    ["GAWEAP", new BasicBuilding(15, 1)], // War Factory
+    ["GAPILE", new BasicBuilding(12, 1)], // Barracks
+    ["CMIN", new Harvester(15, 4, 2)], // Chrono Miner
+    ["ENGINEER", new BasicBuilding(1, 1, 10000)], // Engineer
+    ["GADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
+    ["GAAIRC", new BasicBuilding(8, 1, 6000)], // Airforce Command
+
+    ["GAPILL", new AntiGroundStaticDefence(5, 1, 5)], // Pillbox
+    ["ATESLA", new AntiGroundStaticDefence(5, 1, 10)], // Prism Cannon
+    ["GAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
+
+    ["E1", new BasicGroundUnit(5, 3, 0.25, 0)], // GI
+    ["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
+    ["JUMPJET", new BasicAirUnit(10, 1, 1, 1)], // Rocketeer
+    ["SREF", new ArtilleryUnit(9, 1)], // Prism Tank
+    ["CLEG", new BasicGroundUnit(0, 0)], // Chrono Legionnaire (Disabled - we don't handle the warped out phase properly and it tends to bug both bots out)
+    ["SHAD", new BasicGroundUnit(0, 0)], // Nighthawk (Disabled)
+
+    // Soviet
+    ["NAPOWR", new PowerPlant()],
+    ["NAREFN", new ResourceCollectionBuilding(10, 3)], // Refinery
+    ["NAWEAP", new BasicBuilding(15, 1)], // War Factory
+    ["NAHAND", new BasicBuilding(12, 1)], // Barracks
+    ["HARV", new Harvester(15, 4, 2)], // War Miner
+    ["SENGINEER", new BasicBuilding(1, 1, 10000)], // Soviet Engineer
+    ["NADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
+    ["NARADR", new BasicBuilding(8, 1, 4000)], // Radar
+
+    ["NALASR", new AntiGroundStaticDefence(5, 1, 5)], // Sentry Gun
+    ["TESLA", new AntiGroundStaticDefence(5, 1, 10)], // Tesla Coil
+    ["NAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
+
+    ["E2", new BasicGroundUnit(5, 3, 0.25, 0)], // Conscript
+    ["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
+    ["ZEP", new BasicAirUnit(5, 1, 5, 1)], // Kirov
+    ["V3", new ArtilleryUnit(9, 1)], // V3 Rocket Launcher
+]);

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

@@ -0,0 +1,27 @@
+import { GameApi, PlayerData, Point2D, TechnoRules, Tile } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { BasicBuilding } from "./basicBuilding.js";
+import { BasicGroundUnit } from "./basicGroundUnit.js";
+
+const IDEAL_HARVESTERS_PER_REFINERY = 2;
+
+export class Harvester extends BasicGroundUnit {
+    constructor(basePriority: number, baseAmount: number, private minNeeded: number) {
+        super(basePriority, baseAmount, 0, 0);
+    }
+
+    // Priority goes up when we have fewer than this many refineries.
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | undefined
+    ): number {
+        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 ? 5 : 1;
+
+        return this.basePriority * (refineries / Math.max(harvesters / IDEAL_HARVESTERS_PER_REFINERY, 1)) * boost;
+    }
+}

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

@@ -0,0 +1,32 @@
+import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { AiBuildingRules, getDefaultPlacementLocation } from "./building.js";
+import { GlobalThreat } from "../threat/threat.js";
+
+export class PowerPlant implements AiBuildingRules {
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules
+    ): { rx: number; ry: number } | undefined {
+        return getDefaultPlacementLocation(game, playerData, playerData.startLocation, technoRules);
+    }
+
+    getPriority(game: GameApi, playerData: PlayerData, technoRules: TechnoRules): number {
+        if (playerData.power.total < playerData.power.drain) {
+            return 100;
+        } else if (playerData.power.total < playerData.power.drain + technoRules.power / 2) {
+            return 20;
+        } else {
+            return 0;
+        }
+    }
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | undefined
+    ): number | null {
+        return null;
+    }
+}

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

@@ -0,0 +1,255 @@
+import {
+    ActionsApi,
+    GameApi,
+    PlayerData,
+    ProductionApi,
+    QueueStatus,
+    QueueType,
+    TechnoRules,
+} from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat";
+import {
+    TechnoRulesWithPriority,
+    BUILDING_NAME_TO_RULES,
+    DEFAULT_BUILDING_PRIORITY,
+    getDefaultPlacementLocation,
+} from "./building.js";
+
+export const QUEUES = [
+    QueueType.Structures,
+    QueueType.Armory,
+    QueueType.Infantry,
+    QueueType.Vehicles,
+    QueueType.Aircrafts,
+    QueueType.Ships,
+];
+
+export const queueTypeToName = (queue: QueueType) => {
+    switch (queue) {
+        case QueueType.Structures:
+            return "Structures";
+        case QueueType.Armory:
+            return "Armory";
+        case QueueType.Infantry:
+            return "Infantry";
+        case QueueType.Vehicles:
+            return "Vehicles";
+        case QueueType.Aircrafts:
+            return "Aircrafts";
+        case QueueType.Ships:
+            return "Ships";
+        default:
+            return "Unknown";
+    }
+};
+
+// Repair buildings at this ratio of the maxHitpoints.
+const REPAIR_HITPOINTS_RATIO = 0.9;
+
+// Don't repair buildings more often than this.
+const REPAIR_COOLDOWN_TICKS = 15;
+
+const DEBUG_BUILD_QUEUES = true;
+
+export class QueueController {
+    constructor(
+        private buildingIdToLastHitpoints: Map<number, number> = new Map(),
+        private buildingIdLastRepairedAtTick: Map<number, number> = new Map()
+    ) {}
+
+    public onAiUpdate(
+        game: GameApi,
+        productionApi: ProductionApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        threatCache: GlobalThreat | undefined,
+        logger: (message: string) => void
+    ) {
+        const decisions = QUEUES.map((queueType) => {
+            const options = productionApi.getAvailableObjects(queueType);
+            return {
+                queue: queueType,
+                decision: this.getBestOptionForBuilding(game, options, threatCache, playerData, logger),
+            };
+        }).filter((decision) => decision.decision != null);
+        let totalWeightAcrossQueues = decisions
+            .map((decision) => decision.decision?.priority!)
+            .reduce((pV, cV) => pV + cV, 0);
+        let totalCostAcrossQueues = decisions
+            .map((decision) => decision.decision?.unit.cost!)
+            .reduce((pV, cV) => pV + cV, 0);
+
+        decisions.forEach((decision) => {
+            this.updateBuildQueue(
+                game,
+                productionApi,
+                actionsApi,
+                playerData,
+                threatCache,
+                decision.queue,
+                decision.decision,
+                totalWeightAcrossQueues,
+                totalCostAcrossQueues,
+                logger
+            );
+        });
+
+        // Repair is simple - just repair everything that's damaged.
+        // Unfortunately there doesn't seem to be an API to determine if something is being repaired, so we have to remember it.
+        game.getVisibleUnits(playerData.name, "self", (r) => r.repairable).forEach((unitId) => {
+            const unit = game.getUnitData(unitId);
+            if (!unit || !unit.hitPoints || !unit.maxHitPoints) {
+                return;
+            }
+            const lastKnownHitpoints = this.buildingIdToLastHitpoints.get(unitId) || unit.hitPoints;
+            const buildingLastRepairedAt = this.buildingIdLastRepairedAtTick.get(unitId) || 0;
+            // Only repair if HP is going down and if we haven't recently repaired it
+            if (
+                unit.hitPoints <= lastKnownHitpoints &&
+                game.getCurrentTick() > buildingLastRepairedAt + REPAIR_COOLDOWN_TICKS &&
+                unit.hitPoints < unit.maxHitPoints * REPAIR_HITPOINTS_RATIO
+            ) {
+                actionsApi.toggleRepairWrench(unitId);
+                this.buildingIdLastRepairedAtTick.set(unitId, game.getCurrentTick());
+            }
+            this.buildingIdToLastHitpoints.set(unitId, unit.hitPoints);
+        });
+    }
+
+    private updateBuildQueue(
+        game: GameApi,
+        productionApi: ProductionApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        threatCache: GlobalThreat | undefined,
+        queueType: QueueType,
+        decision: TechnoRulesWithPriority | undefined,
+        totalWeightAcrossQueues: number,
+        totalCostAcrossQueues: number,
+        logger: (message: string) => void
+    ): void {
+        const myCredits = playerData.credits;
+
+        let queueData = productionApi.getQueueData(queueType);
+        if (queueData.status == QueueStatus.Idle) {
+            // Start building the decided item.
+            if (decision !== undefined) {
+                logger(`Decision (${queueTypeToName(queueType)}): ${decision.unit.name}`);
+                actionsApi.queueForProduction(queueType, decision.unit.name, decision.unit.type, 1);
+            }
+        } else if (queueData.status == QueueStatus.Ready && queueData.items.length > 0) {
+            // 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) {
+                    actionsApi.placeBuilding(objectReady.name, location.rx, location.ry);
+                }
+            }
+        } 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) {
+                // Changing our mind.
+                let currentItemPriority = this.getPriorityForBuildingOption(current, game, playerData, threatCache);
+                let newItemPriority = decision.priority;
+                if (newItemPriority > currentItemPriority * 2) {
+                    logger(
+                        `Dequeueing queue ${queueTypeToName(queueData.type)} unit ${current.name} because ${
+                            decision.unit.name
+                        } has 2x higher priority.`
+                    );
+                    actionsApi.unqueueFromProduction(queueData.type, current.name, current.type, 1);
+                }
+            } else {
+                // Not changing our mind, but maybe other queues are more important for now.
+                if (totalCostAcrossQueues > myCredits && decision.priority < totalWeightAcrossQueues * 0.25) {
+                    logger(
+                        `Pausing queue ${queueTypeToName(queueData.type)} because weight is low (${
+                            decision.priority
+                        }/${totalWeightAcrossQueues})`
+                    );
+                    actionsApi.pauseProduction(queueData.type);
+                }
+            }
+        } else if (queueData.status == QueueStatus.OnHold) {
+            // Consider resuming queue if priority is high relative to other queues.
+            if (myCredits >= totalCostAcrossQueues) {
+                logger(`Resuming queue ${queueTypeToName(queueData.type)} because credits are high`);
+                actionsApi.resumeProduction(queueData.type);
+            } else if (decision && decision.priority >= totalWeightAcrossQueues * 0.25) {
+                logger(
+                    `Resuming queue ${queueTypeToName(queueData.type)} because weight is high (${
+                        decision.priority
+                    }/${totalWeightAcrossQueues})`
+                );
+                actionsApi.resumeProduction(queueData.type);
+            }
+        }
+    }
+
+    private getBestOptionForBuilding(
+        game: GameApi,
+        options: TechnoRules[],
+        threatCache: GlobalThreat | undefined,
+        playerData: PlayerData,
+        logger: (message: string) => void
+    ): TechnoRulesWithPriority | undefined {
+        let priorityQueue: TechnoRulesWithPriority[] = [];
+        options.forEach((option) => {
+            let priority = this.getPriorityForBuildingOption(option, game, playerData, threatCache);
+            if (priority > 0) {
+                priorityQueue.push({ unit: option, priority: priority });
+            }
+        });
+
+        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();
+    }
+
+    private getPriorityForBuildingOption(
+        option: TechnoRules,
+        game: GameApi,
+        playerStatus: PlayerData,
+        threatCache: GlobalThreat | undefined
+    ) {
+        if (BUILDING_NAME_TO_RULES.has(option.name)) {
+            let logic = BUILDING_NAME_TO_RULES.get(option.name)!;
+            return logic.getPriority(game, playerStatus, option, threatCache);
+        } else {
+            // Fallback priority when there are no rules.
+            return (
+                DEFAULT_BUILDING_PRIORITY - game.getVisibleUnits(playerStatus.name, "self", (r) => r == option).length
+            );
+        }
+    }
+
+    private getBestLocationForStructure(
+        game: GameApi,
+        playerData: PlayerData,
+        objectReady: TechnoRules
+    ): { rx: number; ry: number } | undefined {
+        if (BUILDING_NAME_TO_RULES.has(objectReady.name)) {
+            let logic = BUILDING_NAME_TO_RULES.get(objectReady.name)!;
+            return logic.getPlacementLocation(game, playerData, objectReady);
+        } else {
+            // fallback placement logic
+            return getDefaultPlacementLocation(game, playerData, playerData.startLocation, objectReady);
+        }
+    }
+}

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

@@ -0,0 +1,56 @@
+import { GameApi, PlayerData, Point2D, TechnoRules, Tile } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { BasicBuilding } from "./basicBuilding.js";
+import {
+    AiBuildingRules,
+    getDefaultPlacementLocation,
+    numBuildingsOwnedOfName,
+    numBuildingsOwnedOfType,
+} from "./building.js";
+
+export class ResourceCollectionBuilding extends BasicBuilding {
+    constructor(basePriority: number, maxNeeded: number, onlyBuildWhenFloatingCreditsAmount?: number) {
+        super(basePriority, maxNeeded, onlyBuildWhenFloatingCreditsAmount);
+    }
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules
+    ): { rx: number; ry: number } | undefined {
+        // Prefer spawning close to ore.
+        let selectedLocation = playerData.startLocation;
+
+        var closeOre: Tile | undefined;
+        var closeOreDist: number | undefined;
+        let allTileResourceData = game.mapApi.getAllTilesResourceData();
+        for (let i = 0; i < allTileResourceData.length; ++i) {
+            let tileResourceData = allTileResourceData[i];
+            if (tileResourceData.spawnsOre) {
+                let dist = Math.sqrt(
+                    (selectedLocation.x - tileResourceData.tile.rx) ** 2 +
+                        (selectedLocation.y - tileResourceData.tile.ry) ** 2
+                );
+                if (closeOreDist == undefined || dist < closeOreDist) {
+                    closeOreDist = dist;
+                    closeOre = tileResourceData.tile;
+                }
+            }
+        }
+        if (closeOre) {
+            selectedLocation = { x: closeOre.rx, y: closeOre.ry };
+        }
+        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules);
+    }
+
+    // Don't build/start selling these if we don't have any harvesters
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | undefined
+    ): number | null {
+        const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
+        return Math.max(1, harvesters * 2);
+    }
+}

package/src/bot/logic/map/map.ts

@@ -0,0 +1,76 @@
+import { GameApi, MapApi, PlayerData, Point2D } from "@chronodivide/game-api";
+
+// Expensive one-time call to determine the size of the map.
+// The result is a point just outside the bounds of the map.
+export function determineMapBounds(mapApi: MapApi): Point2D {
+    // TODO Binary Search this.
+    // Start from the last spawn positions to save time.
+    let maxX: number = 0;
+    let maxY: number = 0;
+    mapApi.getStartingLocations().forEach((point) => {
+        if (point.x > maxX) {
+            maxX = point.x;
+        }
+        if (point.y > maxY) {
+            maxY = point.y;
+        }
+    });
+    // Expand outwards until we find the bounds.
+    for (let testX = maxX; testX < 10000; ++testX) {
+        if (mapApi.getTile(testX, 0) == undefined) {
+            maxX = testX;
+            break;
+        }
+    }
+    for (let testY = maxY; testY < 10000; ++testY) {
+        if (mapApi.getTile(testY, 0) == undefined) {
+            maxY = testY;
+            break;
+        }
+    }
+    return { x: maxX, y: maxY };
+}
+
+export function calculateAreaVisibility(
+    mapApi: MapApi,
+    playerData: PlayerData,
+    startPoint: Point2D,
+    endPoint: Point2D,
+): { visibleTiles: number; validTiles: number } {
+    let validTiles: number = 0,
+        visibleTiles: number = 0;
+    for (let xx = startPoint.x; xx < endPoint.x; ++xx) {
+        for (let yy = startPoint.y; yy < endPoint.y; ++yy) {
+            let tile = mapApi.getTile(xx, yy);
+            if (tile) {
+                ++validTiles;
+                if (mapApi.isVisibleTile(tile, playerData.name)) {
+                    ++visibleTiles;
+                }
+            }
+        }
+    }
+    let result = { visibleTiles, validTiles };
+    return result;
+}
+
+export function getPointTowardsOtherPoint(
+    gameApi: GameApi,
+    startLocation: Point2D,
+    endLocation: Point2D,
+    minRadius: number,
+    maxRadius: number,
+    randomAngle: number,
+): Point2D {
+    let radius = minRadius + Math.round(gameApi.generateRandom() * (maxRadius - minRadius));
+    let directionToSpawn = Math.atan2(endLocation.y - startLocation.y, endLocation.x - startLocation.x);
+    let randomisedDirection =
+        directionToSpawn - (randomAngle * (Math.PI / 12) + 2 * randomAngle * gameApi.generateRandom() * (Math.PI / 12));
+    let candidatePointX = Math.round(startLocation.x + Math.cos(randomisedDirection) * radius);
+    let candidatePointY = Math.round(startLocation.y + Math.sin(randomisedDirection) * radius);
+    return { x: candidatePointX, y: candidatePointY };
+}
+
+export function getDistanceBetweenPoints(startLocation: Point2D, endLocation: Point2D): number {
+    return Math.sqrt((startLocation.x - endLocation.x) ** 2 + (startLocation.y - endLocation.y) ** 2);
+}