@supalosa/chronodivide-bot 0.3.1 → 0.5.1

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

@@ -0,0 +1,64 @@
+import { GameApi, PlayerData, TechnoRules, Vector2 } from "@chronodivide/game-api";
+import { getPointTowardsOtherPoint } from "../map/map.js";
+import { GlobalThreat } from "../threat/threat.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
+
+export class AntiAirStaticDefence implements AiBuildingRules {
+    constructor(
+        private basePriority: number,
+        private baseAmount: number,
+        private airStrength: 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: 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);
+    }
+
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null,
+    ): number {
+        if (threatCache) {
+            let denominator = threatCache.totalAvailableAntiAirFirepower + this.airStrength;
+            if (threatCache.totalOffensiveAirThreat > denominator * 1.1) {
+                return this.basePriority * (threatCache.totalOffensiveAirThreat / Math.max(1, denominator));
+            } else {
+                return 0;
+            }
+        }
+        const strengthPerCost = (this.airStrength / 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/antiGroundStaticDefence.ts

@@ -2,12 +2,13 @@ import { GameApi, PlayerData, TechnoRules, Vector2 } from "@chronodivide/game-ap
 import { getPointTowardsOtherPoint } from "../map/map.js";
 import { GlobalThreat } from "../threat/threat.js";
 import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
+import { getStaticDefencePlacement } from "./common.js";
 
 export class AntiGroundStaticDefence implements AiBuildingRules {
     constructor(
         private basePriority: number,
         private baseAmount: number,
-        private strength: number,
+        private groundStrength: number,
     ) {}
 
     getPlacementLocation(
@@ -15,23 +16,7 @@ export class AntiGroundStaticDefence implements AiBuildingRules {
         playerData: PlayerData,
         technoRules: TechnoRules,
     ): { rx: number; ry: number } | undefined {
-        // 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, 0);
+        return getStaticDefencePlacement(game, playerData, technoRules);
     }
 
     getPriority(
@@ -43,12 +28,14 @@ export class AntiGroundStaticDefence implements AiBuildingRules {
         // If the enemy's ground power is increasing we should try to keep up.
         if (threatCache) {
             let denominator =
-                threatCache.totalAvailableAntiGroundFirepower + threatCache.totalDefensivePower + this.strength;
+                threatCache.totalAvailableAntiGroundFirepower + threatCache.totalDefensivePower + this.groundStrength;
             if (threatCache.totalOffensiveLandThreat > denominator * 1.1) {
                 return this.basePriority * (threatCache.totalOffensiveLandThreat / Math.max(1, denominator));
+            } else {
+                return 0;
             }
         }
-        const strengthPerCost = (this.strength / technoRules.cost) * 1000;
+        const strengthPerCost = (this.groundStrength / technoRules.cost) * 1000;
         const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
         return this.basePriority * (1.0 - numOwned / this.baseAmount) * strengthPerCost;
     }

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

@@ -24,34 +24,8 @@ export class ArtilleryUnit implements AiBuildingRules {
         technoRules: TechnoRules,
         threatCache: GlobalThreat | null,
     ): number {
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        let priority = this.basePriority;
-        // If the enemy's defensive power is increasing we will start to build these.
-        if (threatCache && threatCache.totalDefensivePower > threatCache.totalAvailableAntiGroundFirepower) {
-            priority +=
-                this.artilleryPower *
-                (threatCache.totalAvailableAntiGroundFirepower / Math.max(1, threatCache.totalDefensivePower));
-        }
-        if (threatCache && this.antiGroundPower > 0) {
-            // If the enemy's power is increasing we should try to keep up.
-            if (threatCache.totalOffensiveLandThreat > threatCache.totalAvailableAntiGroundFirepower) {
-                priority +=
-                    this.antiGroundPower *
-                    this.basePriority *
-                    (threatCache.totalOffensiveLandThreat / Math.max(1, threatCache.totalAvailableAntiGroundFirepower));
-            } else {
-                // But also, if our power dwarfs the enemy, keep pressing the advantage.
-                priority +=
-                    (this.antiGroundPower *
-                        this.basePriority *
-                        GameMath.sqrt(
-                            threatCache.totalAvailableAntiGroundFirepower /
-                                Math.max(1, threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat),
-                        )) /
-                    (numOwned + 1);
-            }
-        }
-        return priority * (1.0 - numOwned / this.baseAmount);
+        // Units aren't built automatically, but are instead requested by missions.
+        return 0;
     }
 
     getMaxCount(

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

@@ -24,39 +24,8 @@ export class BasicAirUnit implements AiBuildingRules {
         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,
-                    GameMath.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);
+        // Units aren't built automatically, but are instead requested by missions.
+        return 0;
     }
 
     getMaxCount(

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

@@ -6,13 +6,13 @@ export class BasicBuilding implements AiBuildingRules {
     constructor(
         protected basePriority: number,
         protected maxNeeded: number,
-        protected onlyBuildWhenFloatingCreditsAmount?: number
+        protected onlyBuildWhenFloatingCreditsAmount?: number,
     ) {}
 
     getPlacementLocation(
         game: GameApi,
         playerData: PlayerData,
-        technoRules: TechnoRules
+        technoRules: TechnoRules,
     ): { rx: number; ry: number } | undefined {
         return getDefaultPlacementLocation(game, playerData, playerData.startLocation, technoRules);
     }
@@ -21,7 +21,7 @@ export class BasicBuilding implements AiBuildingRules {
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
+        threatCache: GlobalThreat | null,
     ): number {
         const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
         const calcMaxCount = this.getMaxCount(game, playerData, technoRules, threatCache);
@@ -29,18 +29,20 @@ export class BasicBuilding implements AiBuildingRules {
             return -100;
         }
 
+        const priority = this.basePriority * (1.0 - numOwned / this.maxNeeded);
+
         if (this.onlyBuildWhenFloatingCreditsAmount && playerData.credits < this.onlyBuildWhenFloatingCreditsAmount) {
-            return -100;
+            return priority * (playerData.credits / this.onlyBuildWhenFloatingCreditsAmount);
         }
 
-        return this.basePriority * (1.0 - numOwned / this.maxNeeded);
+        return priority;
     }
 
     getMaxCount(
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
+        threatCache: GlobalThreat | null,
     ): number | null {
         return this.maxNeeded;
     }

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

@@ -24,52 +24,8 @@ export class BasicGroundUnit implements AiBuildingRules {
         technoRules: TechnoRules,
         threatCache: GlobalThreat | null,
     ): number {
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        if (threatCache) {
-            let priority = this.basePriority;
-            if (this.antiGroundPower > 0) {
-                // If the enemy's power is increasing we should try to keep up.
-                if (threatCache.totalOffensiveLandThreat > threatCache.totalAvailableAntiGroundFirepower) {
-                    priority +=
-                        this.antiGroundPower *
-                        this.basePriority *
-                        (threatCache.totalOffensiveLandThreat /
-                            Math.max(1, threatCache.totalAvailableAntiGroundFirepower));
-                } else {
-                    // But also, if our power dwarfs the enemy, keep pressing the advantage.
-                    priority +=
-                        (this.antiGroundPower *
-                            this.basePriority *
-                            GameMath.sqrt(
-                                threatCache.totalAvailableAntiGroundFirepower /
-                                    Math.max(
-                                        1,
-                                        threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat,
-                                    ),
-                            )) /
-                        (numOwned + 1);
-                }
-            }
-            if (this.antiAirPower > 0) {
-                if (threatCache.totalOffensiveAirThreat > threatCache.totalAvailableAntiAirFirepower) {
-                    priority +=
-                        this.antiAirPower *
-                        this.basePriority *
-                        (threatCache.totalOffensiveAirThreat / Math.max(1, threatCache.totalAvailableAntiAirFirepower));
-                } else {
-                    priority +=
-                        (this.antiAirPower *
-                            this.basePriority *
-                            GameMath.sqrt(
-                                threatCache.totalAvailableAntiAirFirepower /
-                                    Math.max(1, threatCache.totalOffensiveAirThreat + threatCache.totalDefensiveThreat),
-                            )) /
-                        (numOwned + 1);
-                }
-            }
-            return priority;
-        }
-        return this.basePriority * (1.0 - numOwned / this.baseAmount);
+        // Units aren't built automatically, but are instead requested by missions.
+        return 0;
     }
 
     getMaxCount(

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

@@ -2,6 +2,7 @@ import {
     BuildingPlacementData,
     GameApi,
     GameMath,
+    LandType,
     ObjectType,
     PlayerData,
     Size,
@@ -19,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(
@@ -51,21 +53,23 @@ export function numBuildingsOwnedOfName(game: GameApi, playerData: PlayerData, n
 }
 
 /**
- * Computes a rect 'centered' around a structure of a certain size with additional radius.
+ * Computes a rect 'centered' around a structure of a certain size with an additional radius (`adjacent`).
+ * The radius is optionally expanded by the size of the new building.
  *
- * This is essentially the placeable area around a given structure.
+ * This is essentially the candidate placement 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.
+ * @param adjacent Amount to expand the building's inner rect by (so buildings must be adjacent by this many tiles)
+ * @param newBuildingSize? Size of the new building
  * @returns
  */
-function computeAdjacentRect(point: Vector2, t: Size, adjacent: number) {
+function computeAdjacentRect(point: Vector2, t: Size, adjacent: number, newBuildingSize?: Size) {
     return {
-        x: point.x - adjacent,
-        y: point.y - adjacent,
-        width: t.width + 2 * adjacent,
-        height: t.height + 2 * adjacent,
+        x: point.x - adjacent - (newBuildingSize?.width || 0),
+        y: point.y - adjacent - (newBuildingSize?.height || 0),
+        width: t.width + 2 * adjacent + (newBuildingSize?.width || 0),
+        height: t.height + 2 * adjacent + (newBuildingSize?.height || 0),
     };
 }
 
@@ -73,8 +77,9 @@ export function getAdjacencyTiles(
     game: GameApi,
     playerData: PlayerData,
     technoRules: TechnoRules,
+    onWater: boolean,
     minimumSpace: number,
-) {
+): Tile[] {
     const placementRules = game.getBuildingPlacementData(technoRules.name);
     const { width: newBuildingWidth, height: newBuildingHeight } = placementRules.foundation;
     const tiles = [];
@@ -82,44 +87,48 @@ export function getAdjacencyTiles(
     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 = new Vector2(tile.rx, 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, {
+        if (!building?.rules?.baseNormal) {
+            // This building is not considered for adjacency checks.
+            continue;
+        }
+        const { foundation, tile } = building;
+        const buildingBase = new Vector2(tile.rx, tile.ry);
+        const buildingSize = {
+            width: foundation?.width,
+            height: foundation?.height,
+        };
+        const range = computeAdjacentRect(buildingBase, buildingSize, technoRules.adjacent, placementRules.foundation);
+        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 = new Vector2(
-                buildingBase.x - (newBuildingWidth - 1),
-                buildingBase.y - (newBuildingHeight - 1),
+            })
+            .filter((tile) => !onWater || tile.landType === LandType.Water);
+        tiles.push(...adjacentTiles);
+
+        // Prevent placing the new building on tiles that would cause it to overlap with this building.
+        const modifiedBase = new Vector2(
+            buildingBase.x - (newBuildingWidth - 1),
+            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
             );
-            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));
-        }
+        });
+        buildingTiles.forEach((buildingTile) => removedTiles.add(buildingTile.id));
     }
     // Remove duplicate tiles.
     const withDuplicatesRemoved = uniqBy(tiles, (tile) => tile.id);
@@ -151,17 +160,18 @@ function distance(x1: number, y1: number, x2: number, y2: number) {
 export function getDefaultPlacementLocation(
     game: GameApi,
     playerData: PlayerData,
-    startPoint: Vector2,
+    idealPoint: Vector2,
     technoRules: TechnoRules,
+    onWater: boolean = false,
     minSpace: number = 1,
 ): { rx: number; ry: number } | undefined {
-    // Random location, preferably near start location.
+    // Closest possible location near `startPoint`.
     const size: BuildingPlacementData = game.getBuildingPlacementData(technoRules.name);
     if (!size) {
         return undefined;
     }
-    const tiles = getAdjacencyTiles(game, playerData, technoRules, minSpace);
-    const tileDistances = getTileDistances(startPoint, tiles);
+    const tiles = getAdjacencyTiles(game, playerData, technoRules, onWater, minSpace);
+    const tileDistances = getTileDistances(idealPoint, tiles);
 
     for (let tileDistance of tileDistances) {
         if (tileDistance.tile && game.canPlaceBuilding(playerData.name, technoRules.name, tileDistance.tile)) {
@@ -174,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
@@ -183,18 +193,20 @@ 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)
 
     ["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
@@ -210,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
@@ -218,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;
     }