@supalosa/chronodivide-bot 0.2.2 → 0.3.0

package/src/bot/logic/awareness.ts

@@ -1,4 +1,4 @@
-import { GameApi, ObjectType, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
+import { GameApi, ObjectType, PlayerData, UnitData, Vector2 } from "@chronodivide/game-api";
 import { SectorCache } from "./map/sector";
 import { GlobalThreat } from "./threat/threat";
 import { calculateGlobalThreat } from "./threat/threatCalculator.js";
@@ -25,14 +25,14 @@ export interface MatchAwareness {
     /**
      * Returns the enemy unit IDs in a certain radius of a point
      */
-    getHostilesNearPoint2d(point: Point2D, radius: number): UnitPositionQuery[];
+    getHostilesNearPoint2d(point: Vector2, radius: number): UnitPositionQuery[];
 
     getHostilesNearPoint(x: number, y: number, radius: number): UnitPositionQuery[];
 
     /**
      * Returns the main rally point for the AI, which updates every few ticks.
      */
-    getMainRallyPoint(): Point2D;
+    getMainRallyPoint(): Vector2;
 
     onGameStart(gameApi: GameApi, playerData: PlayerData): void;
 
@@ -53,7 +53,7 @@ export interface MatchAwareness {
 
 const SECTORS_TO_UPDATE_PER_CYCLE = 8;
 
-const RALLY_POINT_UPDATE_INTERVAL_TICKS = 60;
+const RALLY_POINT_UPDATE_INTERVAL_TICKS = 90;
 
 const THREAT_UPDATE_INTERVAL_TICKS = 30;
 
@@ -75,15 +75,15 @@ export class MatchAwarenessImpl implements MatchAwareness {
     constructor(
         private threatCache: GlobalThreat | null,
         private sectorCache: SectorCache,
-        private mainRallyPoint: Point2D,
+        private mainRallyPoint: Vector2,
         private logger: (message: string, sayInGame?: boolean) => void,
     ) {
-        const { x: width, y: height } = sectorCache.getMapBounds();
+        const { width, height } = sectorCache.getMapBounds();
         this.hostileQuadTree = new Quadtree({ width, height });
         this.scoutingManager = new ScoutingManager(logger);
     }
 
-    getHostilesNearPoint2d(point: Point2D, radius: number): UnitPositionQuery[] {
+    getHostilesNearPoint2d(point: Vector2, radius: number): UnitPositionQuery[] {
         return this.getHostilesNearPoint(point.x, point.y, radius);
     }
 
@@ -91,7 +91,7 @@ export class MatchAwarenessImpl implements MatchAwareness {
         const intersections = this.hostileQuadTree.retrieve(new Circle({ x: searchX, y: searchY, r: radius }));
         return intersections
             .map(({ x, y, data: unitId }) => ({ x, y, unitId: unitId! }))
-            .filter(({ x, y }) => getDistanceBetweenPoints({ x, y }, { x: searchX, y: searchY }) <= radius)
+            .filter(({ x, y }) => getDistanceBetweenPoints(new Vector2(x, y), new Vector2(searchX, searchY)) <= radius)
             .filter(({ unitId }) => !!unitId);
     }
 
@@ -101,7 +101,7 @@ export class MatchAwarenessImpl implements MatchAwareness {
     getSectorCache(): SectorCache {
         return this.sectorCache;
     }
-    getMainRallyPoint(): Point2D {
+    getMainRallyPoint(): Vector2 {
         return this.mainRallyPoint;
     }
     getScoutingManager(): ScoutingManager {
@@ -113,11 +113,11 @@ export class MatchAwarenessImpl implements MatchAwareness {
     }
 
     private checkShouldAttack(threatCache: GlobalThreat, threatFactor: number) {
-        let scaledGroundPower = Math.pow(threatCache.totalAvailableAntiGroundFirepower, 1.025);
+        let scaledGroundPower = threatCache.totalAvailableAntiGroundFirepower * 1.1;
         let scaledGroundThreat =
             (threatFactor * threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat) * 1.1;
 
-        let scaledAirPower = Math.pow(threatCache.totalAvailableAirPower, 1.025);
+        let scaledAirPower = threatCache.totalAvailableAirPower * 1.1;
         let scaledAirThreat =
             (threatFactor * threatCache.totalOffensiveAntiAirThreat + threatCache.totalDefensiveThreat) * 1.1;
 
@@ -141,7 +141,7 @@ export class MatchAwarenessImpl implements MatchAwareness {
 
         sectorCache.updateSectors(game.getCurrentTick(), SECTORS_TO_UPDATE_PER_CYCLE, game.mapApi, playerData);
 
-        this.scoutingManager.onAiUpdate(game, playerData);
+        this.scoutingManager.onAiUpdate(game, playerData, sectorCache);
 
         let updateRatio = sectorCache?.getSectorUpdateRatio(game.getCurrentTick() - game.getTickRate() * 60);
         if (updateRatio && updateRatio < 1.0) {
@@ -160,11 +160,7 @@ export class MatchAwarenessImpl implements MatchAwareness {
             .map((other) => other.name);
 
         // Build the quadtree, if this is too slow we should consider doing this periodically.
-        const hostileUnitIds = game.getVisibleUnits(
-            playerData.name,
-            "hostile",
-            (r) => r.isSelectableCombatant || r.type === ObjectType.Building,
-        );
+        const hostileUnitIds = game.getVisibleUnits(playerData.name, "hostile");
         try {
             const hostileUnits = hostileUnitIds
                 .map((id) => game.getUnitData(id))

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

@@ -1,20 +1,24 @@
-import { GameApi, PlayerData, Point2D, TechnoRules } from "@chronodivide/game-api";
+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 "./building.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
 
 export class AntiGroundStaticDefence implements AiBuildingRules {
-    constructor(private basePriority: number, private baseAmount: number, private strength: number) {}
+    constructor(
+        private basePriority: number,
+        private baseAmount: number,
+        private strength: number,
+    ) {}
 
     getPlacementLocation(
         game: GameApi,
         playerData: PlayerData,
-        technoRules: TechnoRules
+        technoRules: TechnoRules,
     ): { rx: number; ry: number } | undefined {
         // Prefer front towards enemy.
         let startLocation = playerData.startLocation;
         let players = game.getPlayers();
-        let enemyFacingLocationCandidates: Point2D[] = [];
+        let enemyFacingLocationCandidates: Vector2[] = [];
         for (let i = 0; i < players.length; ++i) {
             let playerName = players[i];
             if (playerName == playerData.name) {
@@ -22,19 +26,19 @@ export class AntiGroundStaticDefence implements AiBuildingRules {
             }
             let enemyPlayer = game.getPlayerData(playerName);
             enemyFacingLocationCandidates.push(
-                getPointTowardsOtherPoint(game, startLocation, enemyPlayer.startLocation, 4, 16, 1.5)
+                getPointTowardsOtherPoint(game, startLocation, enemyPlayer.startLocation, 4, 16, 1.5),
             );
         }
         let selectedLocation =
             enemyFacingLocationCandidates[Math.floor(game.generateRandom() * enemyFacingLocationCandidates.length)];
-        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules);
+        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules, 0);
     }
 
     getPriority(
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
+        threatCache: GlobalThreat | null,
     ): number {
         // If the enemy's ground power is increasing we should try to keep up.
         if (threatCache) {
@@ -53,7 +57,7 @@ export class AntiGroundStaticDefence implements AiBuildingRules {
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
+        threatCache: GlobalThreat | null,
     ): number | null {
         return null;
     }

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

@@ -0,0 +1,65 @@
+import { GameApi, GameMath, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { AiBuildingRules, numBuildingsOwnedOfType } from "./buildingRules.js";
+
+export class ArtilleryUnit implements AiBuildingRules {
+    constructor(
+        private basePriority: number,
+        private artilleryPower: number,
+        private antiGroundPower: 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 {
+        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);
+    }
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null,
+    ): number | null {
+        return null;
+    }
+}

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

@@ -1,19 +1,19 @@
-import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { GameApi, GameMath, PlayerData, TechnoRules } from "@chronodivide/game-api";
 import { GlobalThreat } from "../threat/threat.js";
-import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.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
+        private antiAirPower: number = 0,
     ) {}
 
     getPlacementLocation(
         game: GameApi,
         playerData: PlayerData,
-        technoRules: TechnoRules
+        technoRules: TechnoRules,
     ): { rx: number; ry: number } | undefined {
         return undefined;
     }
@@ -22,7 +22,7 @@ export class BasicAirUnit implements AiBuildingRules {
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
+        threatCache: GlobalThreat | null,
     ): number {
         // If the enemy's anti-air power is low we might build more.
         if (threatCache) {
@@ -48,8 +48,10 @@ export class BasicAirUnit implements AiBuildingRules {
                 1.0,
                 Math.max(
                     1,
-                    Math.sqrt(threatCache.totalAvailableAirPower / Math.max(1, threatCache.totalOffensiveAntiAirThreat))
-                )
+                    GameMath.sqrt(
+                        threatCache.totalAvailableAirPower / Math.max(1, threatCache.totalOffensiveAntiAirThreat),
+                    ),
+                ),
             );
             return this.baseAmount * priority;
         }
@@ -61,7 +63,7 @@ export class BasicAirUnit implements AiBuildingRules {
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
+        threatCache: GlobalThreat | null,
     ): number | null {
         return null;
     }

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

@@ -1,5 +1,5 @@
 import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
-import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
 import { GlobalThreat } from "../threat/threat.js";
 
 export class BasicBuilding implements AiBuildingRules {

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

@@ -1,6 +1,6 @@
-import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
+import { GameApi, GameMath, PlayerData, TechnoRules } from "@chronodivide/game-api";
 import { GlobalThreat } from "../threat/threat.js";
-import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
 
 export class BasicGroundUnit implements AiBuildingRules {
     constructor(
@@ -40,7 +40,7 @@ export class BasicGroundUnit implements AiBuildingRules {
                     priority +=
                         (this.antiGroundPower *
                             this.basePriority *
-                            Math.sqrt(
+                            GameMath.sqrt(
                                 threatCache.totalAvailableAntiGroundFirepower /
                                     Math.max(
                                         1,
@@ -60,7 +60,7 @@ export class BasicGroundUnit implements AiBuildingRules {
                     priority +=
                         (this.antiAirPower *
                             this.basePriority *
-                            Math.sqrt(
+                            GameMath.sqrt(
                                 threatCache.totalAvailableAntiAirFirepower /
                                     Math.max(1, threatCache.totalOffensiveAirThreat + threatCache.totalDefensiveThreat),
                             )) /

package/src/bot/logic/building/{building.ts → buildingRules.ts}

@@ -1,22 +1,24 @@
 import {
     BuildingPlacementData,
     GameApi,
+    GameMath,
     ObjectType,
     PlayerData,
-    Point2D,
     Size,
     TechnoRules,
     Tile,
+    Vector2,
 } from "@chronodivide/game-api";
 import { GlobalThreat } from "../threat/threat.js";
 import { AntiGroundStaticDefence } from "./antiGroundStaticDefence.js";
-import { ArtilleryUnit } from "./ArtilleryUnit.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 "../common/utils.js";
 
 export interface AiBuildingRules {
     getPriority(
@@ -48,74 +50,118 @@ 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) {
+/**
+ * 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: Vector2, t: Size, adjacent: number) {
     return {
         x: point.x - adjacent,
         y: point.y - adjacent,
         width: t.width + 2 * adjacent,
-        height: t.height + 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
+
+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 = 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;
             }
-            tiles.push(...game.mapApi.getTilesInRect(baseTile,{width:range.width,height:range.height}))
+            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),
+            );
+            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));
         }
     }
-    return tiles
+    // 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[]) {
-    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 getTileDistances(startPoint: Vector2, 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
+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 0;
     }
-    return Math.sqrt(tmp)
+    return GameMath.sqrt(tmp);
 }
 
-
 export function getDefaultPlacementLocation(
     game: GameApi,
     playerData: PlayerData,
-    startPoint: Point2D,
+    startPoint: Vector2,
     technoRules: TechnoRules,
-    space: number = 1,
+    minSpace: number = 1,
 ): { rx: number; ry: number } | undefined {
     // Random location, preferably near start location.
-    let size: BuildingPlacementData = game.getBuildingPlacementData(technoRules.name);
+    const size: BuildingPlacementData = game.getBuildingPlacementData(technoRules.name);
     if (!size) {
         return undefined;
     }
-    let tiles = getAdjacencyTiles(game, playerData, technoRules)
-    let tileDistances = getTileDistances(startPoint, tiles)
+    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)) {
@@ -137,9 +183,9 @@ 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(1, 1, 10000)], // Engineer
+    ["ENGINEER", new BasicBuilding(10, 1, 1000)], // Engineer
     ["GADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
-    ["GAAIRC", new BasicBuilding(8, 1, 6000)], // Airforce Command
+    ["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
@@ -154,7 +200,7 @@ export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
     ["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(9, 1)], // Prism Tank
+    ["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)
 
@@ -164,9 +210,9 @@ 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(1, 1, 10000)], // Soviet Engineer
+    ["SENGINEER", new BasicBuilding(10, 1, 1000)], // Soviet Engineer
     ["NADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
-    ["NARADR", new BasicBuilding(8, 1, 4000)], // Radar
+    ["NARADR", new BasicBuilding(10, 1, 500)], // Radar
     ["NANRCT", new PowerPlant()], // Nuclear Reactor
     ["NAYARD", new BasicBuilding(0, 0, 0)], // Naval Yard, disabled
 
@@ -181,5 +227,5 @@ export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
     ["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
+    ["V3", new ArtilleryUnit(9, 10, 0, 3)], // V3 Rocket Launcher
 ]);

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

@@ -1,12 +1,15 @@
-import { GameApi, PlayerData, Point2D, TechnoRules, Tile } from "@chronodivide/game-api";
+import { GameApi, PlayerData, TechnoRules } 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) {
+    constructor(
+        basePriority: number,
+        baseAmount: number,
+        private minNeeded: number,
+    ) {
         super(basePriority, baseAmount, 0, 0);
     }
 
@@ -15,7 +18,7 @@ export class Harvester extends BasicGroundUnit {
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
+        threatCache: GlobalThreat | null,
     ): number {
         const refineries = game.getVisibleUnits(playerData.name, "self", (r) => r.refinery).length;
         const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;

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

@@ -1,5 +1,5 @@
 import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
-import { AiBuildingRules, getDefaultPlacementLocation } from "./building.js";
+import { AiBuildingRules, getDefaultPlacementLocation } from "./buildingRules.js";
 import { GlobalThreat } from "../threat/threat.js";
 
 export class PowerPlant implements AiBuildingRules {

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,12 +1,8 @@
-import { GameApi, PlayerData, Point2D, TechnoRules, Tile } from "@chronodivide/game-api";
+import { GameApi, GameMath, PlayerData, 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";
+import { getDefaultPlacementLocation } from "./buildingRules.js";
+import { Vector2 } from "three";
 
 export class ResourceCollectionBuilding extends BasicBuilding {
     constructor(basePriority: number, maxNeeded: number, onlyBuildWhenFloatingCreditsAmount?: number) {
@@ -16,7 +12,7 @@ export class ResourceCollectionBuilding extends BasicBuilding {
     getPlacementLocation(
         game: GameApi,
         playerData: PlayerData,
-        technoRules: TechnoRules
+        technoRules: TechnoRules,
     ): { rx: number; ry: number } | undefined {
         // Prefer spawning close to ore.
         let selectedLocation = playerData.startLocation;
@@ -27,9 +23,9 @@ export class ResourceCollectionBuilding extends BasicBuilding {
         for (let i = 0; i < allTileResourceData.length; ++i) {
             let tileResourceData = allTileResourceData[i];
             if (tileResourceData.spawnsOre) {
-                let dist = Math.sqrt(
+                let dist = GameMath.sqrt(
                     (selectedLocation.x - tileResourceData.tile.rx) ** 2 +
-                        (selectedLocation.y - tileResourceData.tile.ry) ** 2
+                        (selectedLocation.y - tileResourceData.tile.ry) ** 2,
                 );
                 if (closeOreDist == undefined || dist < closeOreDist) {
                     closeOreDist = dist;
@@ -38,7 +34,7 @@ export class ResourceCollectionBuilding extends BasicBuilding {
             }
         }
         if (closeOre) {
-            selectedLocation = { x: closeOre.rx, y: closeOre.ry };
+            selectedLocation = new Vector2(closeOre.rx, closeOre.ry);
         }
         return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules);
     }
@@ -48,7 +44,7 @@ export class ResourceCollectionBuilding extends BasicBuilding {
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
+        threatCache: GlobalThreat | null,
     ): number | null {
         const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
         return Math.max(1, harvesters * 2);