@supalosa/chronodivide-bot 0.2.1 → 0.2.2

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

@@ -1,43 +1,43 @@
-import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
-import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
-
-export class ArtilleryUnit implements AiBuildingRules {
-    constructor(private basePriority: number, private baseAmount: number) {}
-
-    getPlacementLocation(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules
-    ): { rx: number; ry: number } | undefined {
-        return undefined;
-    }
-
-    getPriority(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number {
-        // If the enemy's defensive power is increasing we will start to build these.
-        if (threatCache) {
-            if (threatCache.totalDefensivePower > threatCache.totalAvailableAntiGroundFirepower) {
-                return (
-                    this.basePriority *
-                    (threatCache.totalAvailableAntiGroundFirepower / Math.max(1, threatCache.totalDefensivePower))
-                );
-            }
-        }
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        return this.basePriority * (1.0 - numOwned / this.baseAmount);
-    }
-
-    getMaxCount(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number | null {
-        return null;
-    }
-}
+import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
+
+export class ArtilleryUnit implements AiBuildingRules {
+    constructor(private basePriority: number, private baseAmount: number) {}
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules
+    ): { rx: number; ry: number } | undefined {
+        return undefined;
+    }
+
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number {
+        // If the enemy's defensive power is increasing we will start to build these.
+        if (threatCache) {
+            if (threatCache.totalDefensivePower > threatCache.totalAvailableAntiGroundFirepower) {
+                return (
+                    this.basePriority *
+                    (threatCache.totalAvailableAntiGroundFirepower / Math.max(1, threatCache.totalDefensivePower))
+                );
+            }
+        }
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        return this.basePriority * (1.0 - numOwned / this.baseAmount);
+    }
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number | null {
+        return null;
+    }
+}

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

@@ -1,60 +1,60 @@
-import { GameApi, PlayerData, Point2D, TechnoRules } from "@chronodivide/game-api";
-import { getPointTowardsOtherPoint } from "../map/map.js";
-import { GlobalThreat } from "../threat/threat.js";
-import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
-
-export class AntiGroundStaticDefence implements AiBuildingRules {
-    constructor(private basePriority: number, private baseAmount: number, private strength: number) {}
-
-    getPlacementLocation(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules
-    ): { rx: number; ry: number } | undefined {
-        // Prefer front towards enemy.
-        let startLocation = playerData.startLocation;
-        let players = game.getPlayers();
-        let enemyFacingLocationCandidates: Point2D[] = [];
-        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);
-    }
-
-    getPriority(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number {
-        // If the enemy's ground power is increasing we should try to keep up.
-        if (threatCache) {
-            let denominator =
-                threatCache.totalAvailableAntiGroundFirepower + threatCache.totalDefensivePower + this.strength;
-            if (threatCache.totalOffensiveLandThreat > denominator * 1.1) {
-                return this.basePriority * (threatCache.totalOffensiveLandThreat / Math.max(1, denominator));
-            }
-        }
-        const strengthPerCost = (this.strength / technoRules.cost) * 1000;
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        return this.basePriority * (1.0 - numOwned / this.baseAmount) * strengthPerCost;
-    }
-
-    getMaxCount(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number | null {
-        return null;
-    }
-}
+import { GameApi, PlayerData, Point2D, TechnoRules } from "@chronodivide/game-api";
+import { getPointTowardsOtherPoint } from "../map/map.js";
+import { GlobalThreat } from "../threat/threat.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
+
+export class AntiGroundStaticDefence implements AiBuildingRules {
+    constructor(private basePriority: number, private baseAmount: number, private strength: number) {}
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules
+    ): { rx: number; ry: number } | undefined {
+        // Prefer front towards enemy.
+        let startLocation = playerData.startLocation;
+        let players = game.getPlayers();
+        let enemyFacingLocationCandidates: Point2D[] = [];
+        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);
+    }
+
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number {
+        // If the enemy's ground power is increasing we should try to keep up.
+        if (threatCache) {
+            let denominator =
+                threatCache.totalAvailableAntiGroundFirepower + threatCache.totalDefensivePower + this.strength;
+            if (threatCache.totalOffensiveLandThreat > denominator * 1.1) {
+                return this.basePriority * (threatCache.totalOffensiveLandThreat / Math.max(1, denominator));
+            }
+        }
+        const strengthPerCost = (this.strength / technoRules.cost) * 1000;
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        return this.basePriority * (1.0 - numOwned / this.baseAmount) * strengthPerCost;
+    }
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number | null {
+        return null;
+    }
+}

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

@@ -1,68 +1,68 @@
-import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
-import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
-
-export class BasicAirUnit implements AiBuildingRules {
-    constructor(
-        private basePriority: number,
-        private baseAmount: number,
-        private antiGroundPower: number = 1, // boolean for now, but will eventually be used in weighting.
-        private antiAirPower: number = 0
-    ) {}
-
-    getPlacementLocation(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules
-    ): { rx: number; ry: number } | undefined {
-        return undefined;
-    }
-
-    getPriority(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number {
-        // If the enemy's anti-air power is low we might build more.
-        if (threatCache) {
-            let priority = 0;
-            if (
-                this.antiGroundPower > 0 &&
-                threatCache.totalOffensiveLandThreat > threatCache.totalAvailableAntiGroundFirepower
-            ) {
-                priority +=
-                    this.basePriority *
-                    (threatCache.totalOffensiveLandThreat / Math.max(1, threatCache.totalAvailableAntiGroundFirepower));
-            }
-            if (
-                this.antiAirPower > 0 &&
-                threatCache.totalOffensiveAirThreat > threatCache.totalAvailableAntiAirFirepower
-            ) {
-                priority +=
-                    this.basePriority *
-                    (threatCache.totalOffensiveAirThreat / Math.max(1, threatCache.totalAvailableAntiAirFirepower));
-            }
-            // sqrt so we don't build too much of one unit type.
-            priority += Math.min(
-                1.0,
-                Math.max(
-                    1,
-                    Math.sqrt(threatCache.totalAvailableAirPower / Math.max(1, threatCache.totalOffensiveAntiAirThreat))
-                )
-            );
-            return this.baseAmount * priority;
-        }
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        return this.basePriority * (1.0 - numOwned / this.baseAmount);
-    }
-
-    getMaxCount(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number | null {
-        return null;
-    }
-}
+import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
+
+export class BasicAirUnit implements AiBuildingRules {
+    constructor(
+        private basePriority: number,
+        private baseAmount: number,
+        private antiGroundPower: number = 1, // boolean for now, but will eventually be used in weighting.
+        private antiAirPower: number = 0
+    ) {}
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules
+    ): { rx: number; ry: number } | undefined {
+        return undefined;
+    }
+
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number {
+        // If the enemy's anti-air power is low we might build more.
+        if (threatCache) {
+            let priority = 0;
+            if (
+                this.antiGroundPower > 0 &&
+                threatCache.totalOffensiveLandThreat > threatCache.totalAvailableAntiGroundFirepower
+            ) {
+                priority +=
+                    this.basePriority *
+                    (threatCache.totalOffensiveLandThreat / Math.max(1, threatCache.totalAvailableAntiGroundFirepower));
+            }
+            if (
+                this.antiAirPower > 0 &&
+                threatCache.totalOffensiveAirThreat > threatCache.totalAvailableAntiAirFirepower
+            ) {
+                priority +=
+                    this.basePriority *
+                    (threatCache.totalOffensiveAirThreat / Math.max(1, threatCache.totalAvailableAntiAirFirepower));
+            }
+            // sqrt so we don't build too much of one unit type.
+            priority += Math.min(
+                1.0,
+                Math.max(
+                    1,
+                    Math.sqrt(threatCache.totalAvailableAirPower / Math.max(1, threatCache.totalOffensiveAntiAirThreat))
+                )
+            );
+            return this.baseAmount * priority;
+        }
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        return this.basePriority * (1.0 - numOwned / this.baseAmount);
+    }
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number | null {
+        return null;
+    }
+}

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

@@ -1,47 +1,47 @@
-import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
-import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
-import { GlobalThreat } from "../threat/threat.js";
-
-export class BasicBuilding implements AiBuildingRules {
-    constructor(
-        protected basePriority: number,
-        protected maxNeeded: number,
-        protected onlyBuildWhenFloatingCreditsAmount?: number
-    ) {}
-
-    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,
-        threatCache: GlobalThreat | null
-    ): number {
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        const calcMaxCount = this.getMaxCount(game, playerData, technoRules, threatCache);
-        if (numOwned >= (calcMaxCount ?? this.maxNeeded)) {
-            return -100;
-        }
-
-        if (this.onlyBuildWhenFloatingCreditsAmount && playerData.credits < this.onlyBuildWhenFloatingCreditsAmount) {
-            return -100;
-        }
-
-        return this.basePriority * (1.0 - numOwned / this.maxNeeded);
-    }
-
-    getMaxCount(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
-    ): number | null {
-        return this.maxNeeded;
-    }
-}
+import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
+import { GlobalThreat } from "../threat/threat.js";
+
+export class BasicBuilding implements AiBuildingRules {
+    constructor(
+        protected basePriority: number,
+        protected maxNeeded: number,
+        protected onlyBuildWhenFloatingCreditsAmount?: number
+    ) {}
+
+    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,
+        threatCache: GlobalThreat | null
+    ): number {
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        const calcMaxCount = this.getMaxCount(game, playerData, technoRules, threatCache);
+        if (numOwned >= (calcMaxCount ?? this.maxNeeded)) {
+            return -100;
+        }
+
+        if (this.onlyBuildWhenFloatingCreditsAmount && playerData.credits < this.onlyBuildWhenFloatingCreditsAmount) {
+            return -100;
+        }
+
+        return this.basePriority * (1.0 - numOwned / this.maxNeeded);
+    }
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number | null {
+        return this.maxNeeded;
+    }
+}

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

@@ -1,4 +1,13 @@
-import { BuildingPlacementData, GameApi, PlayerData, Point2D, TechnoRules } from "@chronodivide/game-api";
+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";
@@ -39,6 +48,60 @@ export function numBuildingsOwnedOfName(game: GameApi, playerData: PlayerData, n
     return game.getVisibleUnits(playerData.name, "self", (r) => r.name === name).length;
 }
 
+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){
+    let tiles = []
+    let buildings= game.getVisibleUnits(playerData.name,"self",(tech:TechnoRules)=>{ return tech.type === ObjectType.Building })
+    for(let i in buildings){
+        let building = game.getUnitData(buildings[i])
+
+        if(building?.rules?.baseNormal){
+            let foundation = building?.foundation;
+            let range = computeAdjacentRect({x:building?.tile.rx,y:building?.tile.ry},{width:foundation?.width,height:foundation?.height},technoRules.adjacent)
+            let baseTile = game.mapApi.getTile(range.x,range.y)
+            if (!baseTile){
+                continue
+            }
+            tiles.push(...game.mapApi.getTilesInRect(baseTile,{width:range.width,height:range.height}))
+        }
+    }
+    return tiles
+}
+
+
+function getTileDistances(startPoint: Point2D, tiles: Tile[]) {
+    let ret = [];
+    for (let i in tiles) {
+        let currentTile = tiles[i]
+        ret.push({
+            tile:currentTile,
+            distance:distance(currentTile.rx, currentTile.ry, startPoint.x, startPoint.y)
+        })
+    }
+    ret.sort((a,b)=>{
+        return a.distance - b. distance
+    })
+    return ret
+}
+
+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,
@@ -47,21 +110,16 @@ export function getDefaultPlacementLocation(
     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 };
-                }
-            }
+    let tiles = getAdjacencyTiles(game, playerData, technoRules)
+    let 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;

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 "./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;
+    }
+}