@supalosa/chronodivide-bot 0.2.1 → 0.2.2-a

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

@@ -0,0 +1,233 @@
+import {
+    BuildingPlacementData,
+    GameApi,
+    ObjectType,
+    PlayerData,
+    Point2D,
+    Size,
+    TechnoRules,
+    Tile,
+} 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";
+import uniqBy from "lodash.uniqby";
+
+export interface AiBuildingRules {
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null,
+    ): number;
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+    ): { rx: number; ry: number } | undefined;
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null,
+    ): 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;
+}
+
+/**
+ * Computes a rect 'centered' around a structure of a certain size with additional radius.
+ *
+ * This is essentially the placeable area around a given structure.
+ *
+ * @param point Top-left location of the inner rect.
+ * @param t Size of the inner rect.
+ * @param adjacent Size of the outer rect.
+ * @returns
+ */
+function computeAdjacentRect(point: Point2D, t: Size, adjacent: number) {
+    return {
+        x: point.x - adjacent,
+        y: point.y - adjacent,
+        width: t.width + 2 * adjacent,
+        height: t.height + 2 * adjacent,
+    };
+}
+
+export function getAdjacencyTiles(
+    game: GameApi,
+    playerData: PlayerData,
+    technoRules: TechnoRules,
+    minimumSpace: number,
+) {
+    const placementRules = game.getBuildingPlacementData(technoRules.name);
+    const { width: newBuildingWidth, height: newBuildingHeight } = placementRules.foundation;
+    const tiles = [];
+    const buildings = game.getVisibleUnits(playerData.name, "self", (r: TechnoRules) => r.type === ObjectType.Building);
+    const removedTiles = new Set<string>();
+    for (let buildingId of buildings) {
+        const building = game.getUnitData(buildingId);
+        if (building?.rules?.baseNormal) {
+            const { foundation, tile } = building;
+            const buildingBase = {
+                x: tile.rx,
+                y: tile.ry,
+            };
+            const buildingSize = {
+                width: foundation?.width,
+                height: foundation?.height,
+            };
+            const range = computeAdjacentRect(buildingBase, buildingSize, technoRules.adjacent);
+            const baseTile = game.mapApi.getTile(range.x, range.y);
+            if (!baseTile) {
+                continue;
+            }
+            const adjacentTiles = game.mapApi.getTilesInRect(baseTile, {
+                width: range.width,
+                height: range.height,
+            });
+            tiles.push(...adjacentTiles);
+
+            // Prevent placing the new building on tiles that would cause it to overlap with this building.
+            const modifiedBase = {
+                x: buildingBase.x - (newBuildingWidth - 1),
+                y: buildingBase.y - (newBuildingHeight - 1),
+            };
+            const modifiedSize = {
+                width: buildingSize.width + (newBuildingWidth - 1),
+                height: buildingSize.height + (newBuildingHeight - 1),
+            };
+            const blockedRect = computeAdjacentRect(modifiedBase, modifiedSize, minimumSpace);
+            const buildingTiles = adjacentTiles.filter((tile) => {
+                return (
+                    tile.rx >= blockedRect.x &&
+                    tile.rx < blockedRect.x + blockedRect.width &&
+                    tile.ry >= blockedRect.y &&
+                    tile.ry < blockedRect.y + blockedRect.height
+                );
+            });
+            buildingTiles.forEach((buildingTile) => removedTiles.add(buildingTile.id));
+        }
+    }
+    // Remove duplicate tiles.
+    const withDuplicatesRemoved = uniqBy(tiles, (tile) => tile.id);
+    // Remove tiles containing buildings and potentially area around them removed as well.
+    return withDuplicatesRemoved.filter((tile) => !removedTiles.has(tile.id));
+}
+
+function getTileDistances(startPoint: Point2D, tiles: Tile[]) {
+    return tiles
+        .map((tile) => ({
+            tile,
+            distance: distance(tile.rx, tile.ry, startPoint.x, startPoint.y),
+        }))
+        .sort((a, b) => {
+            return a.distance - b.distance;
+        });
+}
+
+function distance(x1: number, y1: number, x2: number, y2: number) {
+    var dx = x1 - x2;
+    var dy = y1 - y2;
+    let tmp = dx * dx + dy * dy;
+    if (0 === tmp) {
+        return 0;
+    }
+    return Math.sqrt(tmp);
+}
+
+export function getDefaultPlacementLocation(
+    game: GameApi,
+    playerData: PlayerData,
+    startPoint: Point2D,
+    technoRules: TechnoRules,
+    minSpace: number = 1,
+): { rx: number; ry: number } | undefined {
+    // Random location, preferably near start location.
+    const size: BuildingPlacementData = game.getBuildingPlacementData(technoRules.name);
+    if (!size) {
+        return undefined;
+    }
+    const tiles = getAdjacencyTiles(game, playerData, technoRules, minSpace);
+    const tileDistances = getTileDistances(startPoint, tiles);
+
+    for (let tileDistance of tileDistances) {
+        if (tileDistance.tile && game.canPlaceBuilding(playerData.name, technoRules.name, tileDistance.tile)) {
+            return tileDistance.tile;
+        }
+    }
+    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(10, 1, 1000)], // Engineer
+    ["GADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
+    ["GAAIRC", new BasicBuilding(10, 1, 500)], // Airforce Command
+
+    ["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
+    ["GAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
+
+    ["E1", new BasicGroundUnit(2, 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
+    ["ORCA", new BasicAirUnit(7, 1, 2, 0)], // Rocketeer
+    ["SREF", new ArtilleryUnit(10, 5, 3, 3)], // 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(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
+    ["NAYARD", new BasicBuilding(0, 0, 0)], // Naval Yard, disabled
+
+    ["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
+    ["NAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
+
+    ["E2", new BasicGroundUnit(2, 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, 10, 0, 3)], // V3 Rocket Launcher
+]);

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

@@ -1,32 +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 | null
-    ): number | null {
-        return null;
-    }
-}
+import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { AiBuildingRules, getDefaultPlacementLocation } from "./buildingRules.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 | null
+    ): number | null {
+        return null;
+    }
+}

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

@@ -13,7 +13,7 @@ import {
     BUILDING_NAME_TO_RULES,
     DEFAULT_BUILDING_PRIORITY,
     getDefaultPlacementLocation,
-} from "./building.js";
+} from "./buildingRules.js";
 
 export const QUEUES = [
     QueueType.Structures,

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

@@ -1,56 +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 | null
-    ): number | null {
-        const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
-        return Math.max(1, harvesters * 2);
-    }
-}
+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 "./buildingRules.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 | null
+    ): number | null {
+        const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
+        return Math.max(1, harvesters * 2);
+    }
+}

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

@@ -1,4 +1,7 @@
-import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { GameApi, PlayerData, Point2D } from "@chronodivide/game-api";
+import { Sector, SectorCache } from "../map/sector";
+import { DebugLogger } from "./utils";
+import { PriorityQueue } from "@datastructures-js/priority-queue";
 
 export const getUnseenStartingLocations = (gameApi: GameApi, playerData: PlayerData) => {
     const unseenStartingLocations = gameApi.mapApi.getStartingLocations().filter((startingLocation) => {
@@ -10,3 +13,126 @@ export const getUnseenStartingLocations = (gameApi: GameApi, playerData: PlayerD
     });
     return unseenStartingLocations;
 };
+
+class PrioritisedScoutTarget {
+    private _targetPoint2D?: Point2D;
+    private _targetSector?: Sector;
+    private _priority: number;
+
+    constructor(priority: number, target: Point2D | Sector) {
+        if (target.hasOwnProperty("x") && target.hasOwnProperty("y")) {
+            this._targetPoint2D = target as Point2D;
+        } else if (target.hasOwnProperty("sectorStartPoint")) {
+            this._targetSector = target as Sector;
+        } else {
+            throw new TypeError(`invalid object passed as target: ${target}`);
+        }
+        this._priority = priority;
+    }
+
+    get priority() {
+        return this._priority;
+    }
+
+    asPoint2D() {
+        return this._targetPoint2D ?? this._targetSector?.sectorStartPoint ?? null;
+    }
+
+    get targetSector() {
+        return this._targetSector;
+    }
+}
+
+const ENEMY_SPAWN_POINT_PRIORITY = 100;
+
+// Amount of sectors around the starting sector to try to scout.
+const NEARBY_SECTOR_RADIUS = 2;
+const NEARBY_SECTOR_BASE_PRIORITY = 1000;
+
+export class ScoutingManager {
+    private scoutingQueue: PriorityQueue<PrioritisedScoutTarget>;
+
+    constructor(private logger: DebugLogger) {
+        // Order by descending priority.
+        this.scoutingQueue = new PriorityQueue((a: PrioritisedScoutTarget, b: PrioritisedScoutTarget) => b.priority - a.priority);
+    }
+
+    onGameStart(gameApi: GameApi, playerData: PlayerData, sectorCache: SectorCache) {
+        // Queue hostile starting locations with high priority.
+        gameApi.mapApi
+            .getStartingLocations()
+            .filter((startingLocation) => {
+                if (startingLocation == playerData.startLocation) {
+                    return false;
+                }
+                let tile = gameApi.mapApi.getTile(startingLocation.x, startingLocation.y);
+                return tile ? !gameApi.mapApi.isVisibleTile(tile, playerData.name) : false;
+            })
+            .map((tile) => new PrioritisedScoutTarget(ENEMY_SPAWN_POINT_PRIORITY, tile))
+            .forEach((target) => {
+                this.logger(`Adding ${target.asPoint2D()?.x},${target.asPoint2D()?.y} to initial scouting queue`);
+                this.scoutingQueue.enqueue(target);
+            });
+
+        // Queue nearby sectors.
+        const { x: startX, y: startY } = playerData.startLocation;
+        const { x: sectorsX, y: sectorsY } = sectorCache.getSectorBounds();
+        const startingSector = sectorCache.getSectorCoordinatesForWorldPosition(startX, startY);
+
+        if (!startingSector) {
+            return;
+        }
+
+        for (
+            let x: number = Math.max(0, startingSector.sectorX - NEARBY_SECTOR_RADIUS);
+            x <= Math.min(sectorsX, startingSector.sectorX + NEARBY_SECTOR_RADIUS);
+            ++x
+        ) {
+            for (
+                let y: number = Math.max(0, startingSector.sectorY - NEARBY_SECTOR_RADIUS);
+                y <= Math.min(sectorsY, startingSector.sectorY + NEARBY_SECTOR_RADIUS);
+                ++y
+            ) {
+                if (x === startingSector?.sectorX && y === startingSector?.sectorY) {
+                    continue;
+                }
+                // Make it scout closer sectors first.
+                const distanceFactor = Math.pow(x - startingSector.sectorX, 2) + Math.pow(y - startingSector.sectorY, 2);
+                const sector = sectorCache.getSector(x, y);
+                if (sector) {
+                    const maybeTarget = new PrioritisedScoutTarget(NEARBY_SECTOR_BASE_PRIORITY - distanceFactor, sector);
+                    const maybePoint = maybeTarget.asPoint2D();
+                    if (maybePoint && gameApi.mapApi.getTile(maybePoint.x, maybePoint.y)) {
+                        this.scoutingQueue.enqueue(maybeTarget);
+                    }
+                }
+            }
+        }
+    }
+
+    onAiUpdate(gameApi: GameApi, playerData: PlayerData) {
+        const currentHead = this.scoutingQueue.front();
+        if (!currentHead) {
+            return;
+        }
+        const head = currentHead.asPoint2D();
+        if (!head) {
+            this.scoutingQueue.dequeue();
+            return;
+        }
+        const { x, y } = head;
+        const tile = gameApi.mapApi.getTile(x, y);
+        if (tile && gameApi.mapApi.isVisibleTile(tile, playerData.name)) {
+            this.logger(`head point is visible, dequeueing`);
+            this.scoutingQueue.dequeue();
+        }
+    }
+
+    getNewScoutTarget() {
+        return this.scoutingQueue.dequeue();
+    }
+
+    hasScoutTargets() {
+        return !this.scoutingQueue.isEmpty();
+    }
+}

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

@@ -0,0 +1,17 @@
+export type DebugLogger = (message: string, sayInGame?: boolean) => void;
+
+// Thanks use-strict!
+export function formatTimeDuration(timeSeconds: number, skipZeroHours = false) {
+    let h = Math.floor(timeSeconds / 3600);
+    timeSeconds -= h * 3600;
+    let m = Math.floor(timeSeconds / 60);
+    timeSeconds -= m * 60;
+    let s = Math.floor(timeSeconds);
+
+    return [...(h || !skipZeroHours ? [h] : []), pad(m, "00"), pad(s, "00")].join(":");
+}
+
+export function pad(n: any, format = "0000") {
+    let str = "" + n;
+    return format.substring(0, format.length - str.length) + str;
+}