@supalosa/chronodivide-bot 0.1.0

package/.prettierrc

@@ -0,0 +1,5 @@
+{
+    "tabWidth": 4,
+    "useTabs": false,
+    "printWidth": 120
+}

package/README.md

@@ -0,0 +1,46 @@
+# Supalosa's Chrono Divine Bot
+
+[Chrono Divide](https://chronodivide.com/) is a ground-up rebuild of Red Alert 2 in the browser. It is feature-complete and allows for online skirmish play against other players.
+It also provides [an API to build bots](https://discord.com/channels/771701199812558848/842700851520339988), as there is no built-in AI yet.
+
+This repository is one such implementation of a bot.
+
+## Development State
+
+Development on this is paused as I'm currently focusing on a Starcraft 2 bot instead.
+The bot only plays Allied, and is not particularly good at the game. Feel free to use its code as a training dummy against your own bot, or extend it if you'd like. Caveat: I'm not a professional AI dev, this was my first foray into this, nor am I particularly experienced with TypeScript or JS.
+
+## Future plans (on hold)
+
+I was working on three things at once before I put this on hold:
+
+-   Task System - Something to not only follow actual build orders, but manage attacks, harass/attack the enemy, perform scouting, expand to other bases etc.
+-   Squad System - Ability to independently control more than one mass of units (i.e. squads), for example a Harass Squad directed by a Harass Task.
+-   Map Control System - Ability to analyse the state of the map and decide whether to fight for control over areas. Currently we already divide the map into square regions with individual threat calculations, but don't really do much with that information.
+
+A lot of these concepts are being built into my Starcraft 2 bot, [Supabot](https://github.com/Supalosa/supabot) - maybe I'll come back to this when I'm done there.
+
+## Install instructions
+
+```sh
+npm install
+npm run build
+npx cross-env MIX_DIR="C:\path_to_ra2_install_dir" npm start
+```
+
+This will create a replay (`.rpl`) file that can be [imported into the live game](https://game.chronodivide.com/).
+
+## Playing against the bot
+
+Contact the developer of Chrono Divide for details if you are seriously interested in playing against a bot (this one or your own).
+
+## Debugging
+
+```sh
+npx cross-env MIX_DIR="C:\path_to_ra2_install_dir" NODE_OPTIONS="--inspect" npm start
+```
+
+# G:\Origin\Ra2_YurisRevenge\Command and Conquer Red Alert II
+
+npx cross-env MIX_DIR="G:\Origin\Ra2_YurisRevenge\Command and Conquer Red Alert II" npm start
+npx cross-env MIX_DIR="G:\Origin\Ra2_YurisRevenge\Command and Conquer Red Alert II" NODE_OPTIONS="--inspect" npm start

package/dist/bot/bot.js

@@ -0,0 +1,269 @@
+import { OrderType, ApiEventType, Bot, QueueStatus, ObjectType, FactoryType, } from "@chronodivide/game-api";
+import { Duration } from "luxon";
+import { determineMapBounds, getDistanceBetweenPoints, getPointTowardsOtherPoint } from "./logic/map/map.js";
+import { SectorCache } from "./logic/map/sector.js";
+import { MissionController } from "./logic/mission/missionController.js";
+import { SquadController } from "./logic/squad/squadController.js";
+import { calculateGlobalThreat } from "./logic/threat/threatCalculator.js";
+import { QUEUES, QueueController, queueTypeToName } from "./logic/building/queueController.js";
+var BotState;
+(function (BotState) {
+    BotState["Initial"] = "init";
+    BotState["Deployed"] = "deployed";
+    BotState["Attacking"] = "attack";
+    BotState["Defending"] = "defend";
+    BotState["Scouting"] = "scout";
+    BotState["Defeated"] = "defeat";
+})(BotState || (BotState = {}));
+const DEBUG_TIMESTAMP_OUTPUT_INTERVAL_SECONDS = 60;
+const NATURAL_TICK_RATE = 15;
+const BOT_AUTO_SURRENDER_TIME_SECONDS = 7200; // 2 hours (approx 30 mins in real game)
+export class ExampleBot extends Bot {
+    constructor(name, country, enableLogging = true) {
+        super(name, country);
+        this.botState = BotState.Initial;
+        this.tickOfLastAttackOrder = 0;
+        this.squadController = new SquadController();
+        this.missionController = new MissionController();
+        this.queueController = new QueueController();
+        this.enableLogging = enableLogging;
+    }
+    onGameStart(game) {
+        const gameRate = game.getTickRate();
+        const botApm = 300;
+        const botRate = botApm / 60;
+        this.tickRatio = Math.ceil(gameRate / botRate);
+        this.enemyPlayers = game.getPlayers().filter((p) => p !== this.name && !game.areAlliedPlayers(this.name, p));
+        this.knownMapBounds = determineMapBounds(game.mapApi);
+        this.sectorCache = new SectorCache(game.mapApi, this.knownMapBounds);
+        this.threatCache = undefined;
+        this.logBotStatus(`Map bounds: ${this.knownMapBounds.x}, ${this.knownMapBounds.y}`);
+    }
+    onGameTick(game) {
+        if ((game.getCurrentTick() / NATURAL_TICK_RATE) % DEBUG_TIMESTAMP_OUTPUT_INTERVAL_SECONDS === 0) {
+            this.logDebugState(game);
+        }
+        if (game.getCurrentTick() % this.tickRatio === 0) {
+            const myPlayer = game.getPlayerData(this.name);
+            const sectorsToUpdatePerCycle = 8; // TODO tune this
+            this.sectorCache?.updateSectors(game.getCurrentTick(), sectorsToUpdatePerCycle, game.mapApi, myPlayer);
+            let updateRatio = this.sectorCache?.getSectorUpdateRatio(game.getCurrentTick() - game.getTickRate() * 60);
+            if (updateRatio && updateRatio < 1.0) {
+                this.logBotStatus(`${updateRatio * 100.0}% of sectors updated in last 60 seconds.`);
+            }
+            // Threat decays over time if we haven't killed anything
+            let boredomFactor = 1.0 -
+                Math.min(1.0, Math.max(0.0, (this.gameApi.getCurrentTick() - this.tickOfLastAttackOrder) / 1600.0));
+            let shouldAttack = this.threatCache ? this.isWorthAttacking(this.threatCache, boredomFactor) : false;
+            if (game.getCurrentTick() % (this.tickRatio * 150) == 0) {
+                let visibility = this.sectorCache?.getOverallVisibility();
+                if (visibility) {
+                    this.logBotStatus(`${Math.round(visibility * 1000.0) / 10}% of tiles visible. Calculating threat.`);
+                    this.threatCache = calculateGlobalThreat(game, myPlayer, visibility);
+                    this.logBotStatus(`Threat LAND: Them ${Math.round(this.threatCache.totalOffensiveLandThreat)}, us: ${Math.round(this.threatCache.totalAvailableAntiGroundFirepower)}.`);
+                    this.logBotStatus(`Threat DEFENSIVE: Them ${Math.round(this.threatCache.totalDefensiveThreat)}, us: ${Math.round(this.threatCache.totalDefensivePower)}.`);
+                    this.logBotStatus(`Threat AIR: Them ${Math.round(this.threatCache.totalOffensiveAirThreat)}, us: ${Math.round(this.threatCache.totalAvailableAntiAirFirepower)}.`);
+                    this.logBotStatus(`Boredom: ${boredomFactor}`);
+                }
+            }
+            if (game.getCurrentTick() / NATURAL_TICK_RATE > BOT_AUTO_SURRENDER_TIME_SECONDS) {
+                this.logBotStatus(`Auto-surrendering after ${BOT_AUTO_SURRENDER_TIME_SECONDS} seconds.`);
+                this.botState = BotState.Defeated;
+                this.actionsApi.quitGame();
+            }
+            // hacky resign condition
+            const armyUnits = game.getVisibleUnits(this.name, "self", (r) => r.isSelectableCombatant);
+            const mcvUnits = game.getVisibleUnits(this.name, "self", (r) => !!r.deploysInto && game.getGeneralRules().baseUnit.includes(r.name));
+            const productionBuildings = game.getVisibleUnits(this.name, "self", (r) => r.type == ObjectType.Building && r.factory != FactoryType.None);
+            if (armyUnits.length == 0 && productionBuildings.length == 0 && mcvUnits.length == 0) {
+                this.logBotStatus(`No army or production left, quitting.`);
+                this.botState = BotState.Defeated;
+                this.actionsApi.quitGame();
+            }
+            // Build logic.
+            this.queueController.onAiUpdate(game, this.productionApi, this.actionsApi, myPlayer, this.threatCache, (message) => this.logBotStatus(message));
+            // Mission logic.
+            this.missionController.onAiUpdate(game, myPlayer, this.threatCache);
+            // Squad logic.
+            this.squadController.onAiUpdate(game, myPlayer, this.threatCache);
+            switch (this.botState) {
+                case BotState.Initial: {
+                    const baseUnits = game.getGeneralRules().baseUnit;
+                    let conYards = game.getVisibleUnits(this.name, "self", (r) => r.constructionYard);
+                    if (conYards.length) {
+                        this.botState = BotState.Deployed;
+                        break;
+                    }
+                    const units = game.getVisibleUnits(this.name, "self", (r) => baseUnits.includes(r.name));
+                    if (units.length) {
+                        this.actionsApi.orderUnits([units[0]], OrderType.DeploySelected);
+                    }
+                    break;
+                }
+                case BotState.Deployed: {
+                    this.botState = BotState.Attacking;
+                    break;
+                }
+                case BotState.Attacking: {
+                    const armyUnits = game.getVisibleUnits(this.name, "self", (r) => r.isSelectableCombatant);
+                    if (!shouldAttack) {
+                        this.logBotStatus(`Not worth attacking, reverting to defence.`);
+                        this.botState = BotState.Defending;
+                    }
+                    const enemyBuildings = game.getVisibleUnits(this.name, "hostile");
+                    let foundTarget = false;
+                    if (enemyBuildings.length) {
+                        const weightedTargets = enemyBuildings
+                            .filter((unit) => this.isHostileUnit(game, unit))
+                            .map((unitId) => {
+                            let unit = game.getUnitData(unitId);
+                            return {
+                                unit,
+                                unitId: unitId,
+                                weight: getDistanceBetweenPoints(myPlayer.startLocation, {
+                                    x: unit.tile.rx,
+                                    y: unit.tile.rx,
+                                }),
+                            };
+                        })
+                            .filter((unit) => unit.unit != null);
+                        weightedTargets.sort((targetA, targetB) => {
+                            return targetA.weight - targetB.weight;
+                        });
+                        const target = weightedTargets.find((_) => true);
+                        if (target !== undefined) {
+                            let targetData = target.unit;
+                            for (const unitId of armyUnits) {
+                                const unit = game.getUnitData(unitId);
+                                foundTarget = true;
+                                if (shouldAttack && unit?.isIdle) {
+                                    let orderType = OrderType.AttackMove;
+                                    if (targetData?.type == ObjectType.Building) {
+                                        orderType = OrderType.Attack;
+                                    }
+                                    else if (targetData?.rules.canDisguise) {
+                                        // Special case for mirage tank/spy as otherwise they just sit next to it.
+                                        orderType = OrderType.Attack;
+                                    }
+                                    this.actionsApi.orderUnits([unitId], orderType, target.unitId);
+                                }
+                            }
+                        }
+                    }
+                    if (!foundTarget) {
+                        this.logBotStatus(`Can't see any targets, scouting.`);
+                        this.botState = BotState.Scouting;
+                    }
+                    break;
+                }
+                case BotState.Defending: {
+                    const armyUnits = game.getVisibleUnits(this.name, "self", (r) => r.isSelectableCombatant);
+                    const enemy = game.getPlayerData(this.enemyPlayers[0]);
+                    const fallbackPoint = getPointTowardsOtherPoint(game, myPlayer.startLocation, enemy.startLocation, 10, 10, 0);
+                    armyUnits.forEach((armyUnitId) => {
+                        let unit = game.getUnitData(armyUnitId);
+                        if (unit && !unit.guardMode) {
+                            let distanceToFallback = getDistanceBetweenPoints({ x: unit.tile.rx, y: unit.tile.ry }, fallbackPoint);
+                            if (distanceToFallback > 10) {
+                                this.actionsApi.orderUnits([armyUnitId], OrderType.GuardArea, fallbackPoint.x, fallbackPoint.y);
+                            }
+                        }
+                    });
+                    if (shouldAttack) {
+                        this.logBotStatus(`Finished defending, ready to attack.`);
+                        this.botState = BotState.Attacking;
+                    }
+                    break;
+                }
+                case BotState.Scouting: {
+                    const armyUnits = game.getVisibleUnits(this.name, "self", (r) => r.isSelectableCombatant);
+                    let candidatePoints = [];
+                    // Move to an unseen starting location.
+                    const unseenStartingLocations = game.mapApi.getStartingLocations().filter((startingLocation) => {
+                        if (startingLocation == game.getPlayerData(this.name).startLocation) {
+                            return false;
+                        }
+                        let tile = game.mapApi.getTile(startingLocation.x, startingLocation.y);
+                        return tile ? !game.mapApi.isVisibleTile(tile, this.name) : false;
+                    });
+                    candidatePoints.push(...unseenStartingLocations);
+                    armyUnits.forEach((unitId) => {
+                        if (candidatePoints.length > 0) {
+                            const unit = game.getUnitData(unitId);
+                            if (unit?.isIdle) {
+                                const scoutLocation = candidatePoints[Math.floor(game.generateRandom() * candidatePoints.length)];
+                                this.actionsApi.orderUnits([unitId], OrderType.AttackMove, scoutLocation.x, scoutLocation.y);
+                            }
+                        }
+                    });
+                    const enemyBuildings = game
+                        .getVisibleUnits(this.name, "hostile")
+                        .filter((unit) => this.isHostileUnit(game, unit));
+                    if (enemyBuildings.length > 0) {
+                        this.logBotStatus(`Scouted a target, reverting to attack mode.`);
+                        this.botState = BotState.Attacking;
+                    }
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+    }
+    getHumanTimestamp(game) {
+        return Duration.fromMillis((game.getCurrentTick() / NATURAL_TICK_RATE) * 1000).toFormat("hh:mm:ss");
+    }
+    logBotStatus(message) {
+        if (!this.enableLogging) {
+            return;
+        }
+        console.log(`[${this.getHumanTimestamp(this.gameApi)} ${this.name} ${this.botState}] ${message}`);
+    }
+    logDebugState(game) {
+        const myPlayer = game.getPlayerData(this.name);
+        const queueState = QUEUES.reduce((prev, queueType) => {
+            if (this.productionApi.getQueueData(queueType).size === 0) {
+                return prev;
+            }
+            const paused = this.productionApi.getQueueData(queueType).status === QueueStatus.OnHold;
+            return (prev +
+                " [" +
+                queueTypeToName(queueType) +
+                (paused ? " PAUSED" : "") +
+                ": " +
+                this.productionApi.getQueueData(queueType).items.map((item) => item.rules.name + "x" + item.quantity) +
+                "]");
+        }, "");
+        this.logBotStatus(`----- Cash: ${myPlayer.credits} ----- | Queues: ${queueState}`);
+        const harvesters = game.getVisibleUnits(this.name, "self", (r) => r.harvester).length;
+        this.logBotStatus(`Harvesters: ${harvesters}`);
+        this.logBotStatus(`----- End -----`);
+    }
+    isWorthAttacking(threatCache, threatFactor) {
+        let scaledGroundPower = Math.pow(threatCache.totalAvailableAntiGroundFirepower, 1.125);
+        let scaledGroundThreat = (threatFactor * threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat) * 1.1;
+        let scaledAirPower = Math.pow(threatCache.totalAvailableAirPower, 1.125);
+        let scaledAirThreat = (threatFactor * threatCache.totalOffensiveAntiAirThreat + threatCache.totalDefensiveThreat) * 1.1;
+        return scaledGroundPower > scaledGroundThreat || scaledAirPower > scaledAirThreat;
+    }
+    isHostileUnit(game, unitId) {
+        const unitData = game.getUnitData(unitId);
+        if (!unitData) {
+            return false;
+        }
+        return unitData.owner != this.name && game.getPlayerData(unitData.owner)?.isCombatant;
+    }
+    onGameEvent(ev) {
+        switch (ev.type) {
+            case ApiEventType.ObjectDestroy: {
+                // Add to the stalemate detection.
+                if (ev.attackerInfo?.playerName == this.name) {
+                    this.tickOfLastAttackOrder += (this.gameApi.getCurrentTick() - this.tickOfLastAttackOrder) / 2;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+}

package/dist/bot/logic/building/ArtilleryUnit.js

@@ -0,0 +1,24 @@
+import { numBuildingsOwnedOfType } from "./building.js";
+export class ArtilleryUnit {
+    constructor(basePriority, baseAmount) {
+        this.basePriority = basePriority;
+        this.baseAmount = baseAmount;
+    }
+    getPlacementLocation(game, playerData, technoRules) {
+        return undefined;
+    }
+    getPriority(game, playerData, technoRules, threatCache) {
+        // 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, playerData, technoRules, threatCache) {
+        return null;
+    }
+}

package/dist/bot/logic/building/antiGroundStaticDefence.js

@@ -0,0 +1,40 @@
+import { getPointTowardsOtherPoint } from "../map/map.js";
+import { getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
+export class AntiGroundStaticDefence {
+    constructor(basePriority, baseAmount, strength) {
+        this.basePriority = basePriority;
+        this.baseAmount = baseAmount;
+        this.strength = strength;
+    }
+    getPlacementLocation(game, playerData, technoRules) {
+        // Prefer front towards enemy.
+        let startLocation = playerData.startLocation;
+        let players = game.getPlayers();
+        let enemyFacingLocationCandidates = [];
+        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, playerData, technoRules, threatCache) {
+        // 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, playerData, technoRules, threatCache) {
+        return null;
+    }
+}

package/dist/bot/logic/building/basicAirUnit.js

@@ -0,0 +1,39 @@
+import { numBuildingsOwnedOfType } from "./building.js";
+export class BasicAirUnit {
+    constructor(basePriority, baseAmount, antiGroundPower = 1, // boolean for now, but will eventually be used in weighting.
+    antiAirPower = 0) {
+        this.basePriority = basePriority;
+        this.baseAmount = baseAmount;
+        this.antiGroundPower = antiGroundPower;
+        this.antiAirPower = antiAirPower;
+    }
+    getPlacementLocation(game, playerData, technoRules) {
+        return undefined;
+    }
+    getPriority(game, playerData, technoRules, threatCache) {
+        // 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, playerData, technoRules, threatCache) {
+        return null;
+    }
+}

package/dist/bot/logic/building/basicBuilding.js

@@ -0,0 +1,25 @@
+import { getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./building.js";
+export class BasicBuilding {
+    constructor(basePriority, maxNeeded, onlyBuildWhenFloatingCreditsAmount) {
+        this.basePriority = basePriority;
+        this.maxNeeded = maxNeeded;
+        this.onlyBuildWhenFloatingCreditsAmount = onlyBuildWhenFloatingCreditsAmount;
+    }
+    getPlacementLocation(game, playerData, technoRules) {
+        return getDefaultPlacementLocation(game, playerData, playerData.startLocation, technoRules);
+    }
+    getPriority(game, playerData, technoRules, threatCache) {
+        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, playerData, technoRules, threatCache) {
+        return this.maxNeeded;
+    }
+}

package/dist/bot/logic/building/basicGroundUnit.js

@@ -0,0 +1,57 @@
+import { numBuildingsOwnedOfType } from "./building.js";
+export class BasicGroundUnit {
+    constructor(basePriority, baseAmount, antiGroundPower = 1, // boolean for now, but will eventually be used in weighting.
+    antiAirPower = 0) {
+        this.basePriority = basePriority;
+        this.baseAmount = baseAmount;
+        this.antiGroundPower = antiGroundPower;
+        this.antiAirPower = antiAirPower;
+    }
+    getPlacementLocation(game, playerData, technoRules) {
+        return undefined;
+    }
+    getPriority(game, playerData, technoRules, threatCache) {
+        if (threatCache) {
+            let priority = 1;
+            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 *
+                            Math.sqrt(threatCache.totalAvailableAntiGroundFirepower /
+                                Math.max(1, threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat));
+                }
+            }
+            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 *
+                            Math.sqrt(threatCache.totalAvailableAntiAirFirepower /
+                                Math.max(1, threatCache.totalOffensiveAirThreat + threatCache.totalDefensiveThreat));
+                }
+            }
+            return priority;
+        }
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        return this.basePriority * (1.0 - numOwned / this.baseAmount);
+    }
+    getMaxCount(game, playerData, technoRules, threatCache) {
+        return null;
+    }
+}

package/dist/bot/logic/building/building.js

@@ -0,0 +1,77 @@
+import { AntiGroundStaticDefence } from "./antiGroundStaticDefence.js";
+import { ArtilleryUnit } from "./ArtilleryUnit.js";
+import { BasicAirUnit } from "./basicAirUnit.js";
+import { BasicBuilding } from "./basicBuilding.js";
+import { BasicGroundUnit } from "./basicGroundUnit.js";
+import { PowerPlant } from "./powerPlant.js";
+import { ResourceCollectionBuilding } from "./resourceCollectionBuilding.js";
+import { Harvester } from "./harvester.js";
+export function numBuildingsOwnedOfType(game, playerData, technoRules) {
+    return game.getVisibleUnits(playerData.name, "self", (r) => r == technoRules).length;
+}
+export function numBuildingsOwnedOfName(game, playerData, name) {
+    return game.getVisibleUnits(playerData.name, "self", (r) => r.name === name).length;
+}
+export function getDefaultPlacementLocation(game, playerData, startPoint, technoRules, space = 1) {
+    // Random location, preferably near start location.
+    let startX = startPoint.x;
+    let startY = startPoint.y;
+    let size = game.getBuildingPlacementData(technoRules.name);
+    if (!size) {
+        return undefined;
+    }
+    let largestSize = Math.max(size.foundation.height, size.foundation.width);
+    for (let searchRadius = largestSize; searchRadius < 25 + largestSize; ++searchRadius) {
+        for (let xx = startX - searchRadius; xx < startX + searchRadius; ++xx) {
+            for (let yy = startY - searchRadius; yy < startY + searchRadius; ++yy) {
+                let tile = game.mapApi.getTile(xx, yy);
+                if (tile && game.canPlaceBuilding(playerData.name, technoRules.name, tile)) {
+                    return { rx: xx, ry: yy };
+                }
+            }
+        }
+    }
+    console.log("Can't find a place to put the " + technoRules.name);
+    return undefined;
+}
+export const DEFAULT_BUILDING_PRIORITY = 1;
+export const BUILDING_NAME_TO_RULES = new Map([
+    // Allied
+    ["GAPOWR", new PowerPlant()],
+    ["GAREFN", new ResourceCollectionBuilding(10, 3)],
+    ["GAWEAP", new BasicBuilding(15, 1)],
+    ["GAPILE", new BasicBuilding(12, 1)],
+    ["CMIN", new Harvester(15, 4, 2)],
+    ["ENGINEER", new BasicBuilding(1, 1, 10000)],
+    ["GADEPT", new BasicBuilding(1, 1, 10000)],
+    ["GAAIRC", new BasicBuilding(8, 1, 6000)],
+    ["GAPILL", new AntiGroundStaticDefence(5, 1, 5)],
+    ["ATESLA", new AntiGroundStaticDefence(5, 1, 10)],
+    ["GAWALL", new AntiGroundStaticDefence(0, 0, 0)],
+    ["E1", new BasicGroundUnit(5, 3, 0.25, 0)],
+    ["MTNK", new BasicGroundUnit(10, 3, 2, 0)],
+    ["MGTK", new BasicGroundUnit(10, 1, 2.5, 0)],
+    ["FV", new BasicGroundUnit(5, 2, 0.5, 1)],
+    ["JUMPJET", new BasicAirUnit(10, 1, 1, 1)],
+    ["SREF", new ArtilleryUnit(9, 1)],
+    ["CLEG", new BasicGroundUnit(0, 0)],
+    ["SHAD", new BasicGroundUnit(0, 0)],
+    // Soviet
+    ["NAPOWR", new PowerPlant()],
+    ["NAREFN", new ResourceCollectionBuilding(10, 3)],
+    ["NAWEAP", new BasicBuilding(15, 1)],
+    ["NAHAND", new BasicBuilding(12, 1)],
+    ["HARV", new Harvester(15, 4, 2)],
+    ["SENGINEER", new BasicBuilding(1, 1, 10000)],
+    ["NADEPT", new BasicBuilding(1, 1, 10000)],
+    ["NARADR", new BasicBuilding(8, 1, 4000)],
+    ["NALASR", new AntiGroundStaticDefence(5, 1, 5)],
+    ["TESLA", new AntiGroundStaticDefence(5, 1, 10)],
+    ["NAWALL", new AntiGroundStaticDefence(0, 0, 0)],
+    ["E2", new BasicGroundUnit(5, 3, 0.25, 0)],
+    ["HTNK", new BasicGroundUnit(10, 3, 3, 0)],
+    ["APOC", new BasicGroundUnit(6, 1, 5, 0)],
+    ["HTK", new BasicGroundUnit(5, 2, 0.33, 1.5)],
+    ["ZEP", new BasicAirUnit(5, 1, 5, 1)],
+    ["V3", new ArtilleryUnit(9, 1)], // V3 Rocket Launcher
+]);

package/dist/bot/logic/building/harvester.js

@@ -0,0 +1,15 @@
+import { BasicGroundUnit } from "./basicGroundUnit.js";
+const IDEAL_HARVESTERS_PER_REFINERY = 2;
+export class Harvester extends BasicGroundUnit {
+    constructor(basePriority, baseAmount, minNeeded) {
+        super(basePriority, baseAmount, 0, 0);
+        this.minNeeded = minNeeded;
+    }
+    // Priority goes up when we have fewer than this many refineries.
+    getPriority(game, playerData, technoRules, threatCache) {
+        const refineries = game.getVisibleUnits(playerData.name, "self", (r) => r.refinery).length;
+        const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
+        const boost = harvesters < this.minNeeded ? 5 : 1;
+        return this.basePriority * (refineries / Math.max(harvesters / IDEAL_HARVESTERS_PER_REFINERY, 1)) * boost;
+    }
+}

package/dist/bot/logic/building/massedAntiGroundUnit.js

@@ -0,0 +1,20 @@
+import { numBuildingsOwnedOfType } from "./building.js";
+export class MassedAntiGroundUnit {
+    constructor(basePriority, baseAmount) {
+        this.basePriority = basePriority;
+        this.baseAmount = baseAmount;
+    }
+    getPlacementLocation(game, playerData, technoRules) {
+        return undefined;
+    }
+    getPriority(game, playerData, technoRules, threatCache) {
+        // If the enemy's ground power is increasing we should try to keep up.
+        if (threatCache) {
+            if (threatCache.totalAvailableAntiGroundFirepower * threatCache.certainty > threatCache.totalAvailableAntiGroundFirepower) {
+                return this.basePriority * (threatCache.totalAvailableAntiGroundFirepower / Math.max(1, threatCache.totalAvailableAntiGroundFirepower));
+            }
+        }
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        return this.basePriority * (1.0 - (numOwned / this.baseAmount));
+    }
+}

package/dist/bot/logic/building/powerPlant.js

@@ -0,0 +1,20 @@
+import { getDefaultPlacementLocation } from "./building.js";
+export class PowerPlant {
+    getPlacementLocation(game, playerData, technoRules) {
+        return getDefaultPlacementLocation(game, playerData, playerData.startLocation, technoRules);
+    }
+    getPriority(game, playerData, technoRules) {
+        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, playerData, technoRules, threatCache) {
+        return null;
+    }
+}