@supalosa/chronodivide-bot 0.1.1 → 0.2.0

package/README.md

@@ -1,46 +1,71 @@
-# 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
+# Supalosa's Chrono Divide 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
+```
+
+# ignore me
+
+export GAMEPATH="G:\Origin\Ra2_YurisRevenge\Command and Conquer Red Alert II"
+
+export GAMEPATH="D:\EA Games\Command and Conquer Red Alert II"
+
+---
+
+npx cross-env MIX_DIR="${GAMEPATH}" npm start
+npx cross-env MIX_DIR="${GAMEPATH}" NODE_OPTIONS="--inspect" npm start
+
+---
+
+ladder maps: https://github.com/chronodivide/pvpgn-server/blob/26bbbe39613751cff696a73f087ce5b4cd938fc8/conf/bnmaps.conf.in#L321-L328
+
+CDR2 1v1 2_malibu_cliffs_le.map
+CDR2 1v1 4_country_swing_le_v2.map
+CDR2 1v1 mp01t4.map
+CDR2 1v1 tn04t2.map
+CDR2 1v1 mp10s4.map
+CDR2 1v1 heckcorners.map
+CDR2 1v1 4_montana_dmz_le.map
+CDR2 1v1 barrel.map
+
+---
+
+to play vs bot
+export SERVER_URL="wss://<region_server>"
+export CLIENT_URL="https://game.chronodivide.com/"

package/dist/bot/bot.js

@@ -1,30 +1,21 @@
-import { OrderType, ApiEventType, Bot, QueueStatus, ObjectType, FactoryType, } from "@chronodivide/game-api";
+import { ApiEventType, Bot, QueueStatus, ObjectType, FactoryType, } from "@chronodivide/game-api";
 import { Duration } from "luxon";
-import { determineMapBounds, getDistanceBetweenPoints, getPointTowardsOtherPoint } from "./logic/map/map.js";
+import { determineMapBounds } 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 = {}));
+import { MatchAwarenessImpl } from "./logic/awareness.js";
 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 {
+const BOT_AUTO_SURRENDER_TIME_SECONDS = 7200; // 7200; // 2 hours (approx 30 mins in real game)
+export class SupalosaBot extends Bot {
     constructor(name, country, enableLogging = true) {
         super(name, country);
-        this.botState = BotState.Initial;
         this.tickOfLastAttackOrder = 0;
+        this.matchAwareness = null;
+        this.missionController = new MissionController((message) => this.logBotStatus(message));
         this.squadController = new SquadController();
-        this.missionController = new MissionController();
         this.queueController = new QueueController();
         this.enableLogging = enableLogging;
     }
@@ -33,42 +24,23 @@ export class ExampleBot extends Bot {
         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.matchAwareness = new MatchAwarenessImpl(null, new SectorCache(game.mapApi, this.knownMapBounds), game.getPlayerData(this.name).startLocation, (msg) => this.logBotStatus(msg));
         this.logBotStatus(`Map bounds: ${this.knownMapBounds.x}, ${this.knownMapBounds.y}`);
     }
     onGameTick(game) {
+        if (!this.matchAwareness) {
+            return;
+        }
+        const threatCache = this.matchAwareness.getThreatCache();
         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}`);
-                }
-            }
+            this.matchAwareness.onAiUpdate(game, myPlayer);
             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
@@ -77,136 +49,17 @@ export class ExampleBot extends Bot {
             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;
+            this.queueController.onAiUpdate(game, this.productionApi, this.actionsApi, myPlayer, threatCache, (message) => this.logBotStatus(message));
+            // Mission logic every 6 ticks
+            if (this.gameApi.getCurrentTick() % 6 === 0) {
+                this.missionController.onAiUpdate(game, myPlayer, this.matchAwareness, this.squadController);
+            }
+            // Squad logic every 3 ticks
+            if (this.gameApi.getCurrentTick() % 3 === 0) {
+                this.squadController.onAiUpdate(game, this.actionsApi, myPlayer, this.matchAwareness, (message) => this.logBotStatus(message));
             }
         }
     }
@@ -217,9 +70,12 @@ export class ExampleBot extends Bot {
         if (!this.enableLogging) {
             return;
         }
-        console.log(`[${this.getHumanTimestamp(this.gameApi)} ${this.name} ${this.botState}] ${message}`);
+        console.log(`[${this.getHumanTimestamp(this.gameApi)} ${this.name}] ${message}`);
     }
     logDebugState(game) {
+        if (!this.enableLogging) {
+            return;
+        }
         const myPlayer = game.getPlayerData(this.name);
         const queueState = QUEUES.reduce((prev, queueType) => {
             if (this.productionApi.getQueueData(queueType).size === 0) {
@@ -238,20 +94,8 @@ export class ExampleBot extends Bot {
         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;
+        this.missionController.logDebugOutput();
+        this.actionsApi.sayAll(`Cash: ${myPlayer.credits}`);
     }
     onGameEvent(ev) {
         switch (ev.type) {

package/dist/bot/logic/awareness.js

@@ -0,0 +1,122 @@
+import { ObjectType } from "@chronodivide/game-api";
+import { calculateGlobalThreat } from "../logic/threat/threatCalculator.js";
+import { getDistanceBetweenPoints, getPointTowardsOtherPoint } from "../logic/map/map.js";
+import { Circle, Quadtree } from "@timohausmann/quadtree-ts";
+const SECTORS_TO_UPDATE_PER_CYCLE = 8;
+const RALLY_POINT_UPDATE_INTERVAL_TICKS = 60;
+const THREAT_UPDATE_INTERVAL_TICKS = 30;
+const rebuildQuadtree = (quadtree, units) => {
+    quadtree.clear();
+    units.forEach((unit) => {
+        quadtree.insert(new Circle({ x: unit.tile.rx, y: unit.tile.ry, r: 1, data: unit.id }));
+    });
+};
+export class MatchAwarenessImpl {
+    constructor(threatCache, sectorCache, mainRallyPoint, logger) {
+        this.threatCache = threatCache;
+        this.sectorCache = sectorCache;
+        this.mainRallyPoint = mainRallyPoint;
+        this.logger = logger;
+        this._shouldAttack = false;
+        const { x: width, y: height } = sectorCache.getMapBounds();
+        this.hostileQuadTree = new Quadtree({ width, height });
+    }
+    getHostilesNearPoint2d(point, radius) {
+        return this.getHostilesNearPoint(point.x, point.y, radius);
+    }
+    getHostilesNearPoint(searchX, searchY, radius) {
+        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(({ unitId }) => !!unitId);
+    }
+    getThreatCache() {
+        return this.threatCache;
+    }
+    getSectorCache() {
+        return this.sectorCache;
+    }
+    getMainRallyPoint() {
+        return this.mainRallyPoint;
+    }
+    shouldAttack() {
+        return this._shouldAttack;
+    }
+    checkShouldAttack(threatCache, threatFactor) {
+        let scaledGroundPower = Math.pow(threatCache.totalAvailableAntiGroundFirepower, 1.025);
+        let scaledGroundThreat = (threatFactor * threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat) * 1.1;
+        let scaledAirPower = Math.pow(threatCache.totalAvailableAirPower, 1.025);
+        let scaledAirThreat = (threatFactor * threatCache.totalOffensiveAntiAirThreat + threatCache.totalDefensiveThreat) * 1.1;
+        return scaledGroundPower > scaledGroundThreat || scaledAirPower > scaledAirThreat;
+    }
+    isHostileUnit(unit, hostilePlayerNames) {
+        if (!unit) {
+            return false;
+        }
+        return hostilePlayerNames.includes(unit.owner);
+    }
+    onAiUpdate(game, playerData) {
+        const sectorCache = this.sectorCache;
+        sectorCache.updateSectors(game.getCurrentTick(), SECTORS_TO_UPDATE_PER_CYCLE, game.mapApi, playerData);
+        let updateRatio = sectorCache?.getSectorUpdateRatio(game.getCurrentTick() - game.getTickRate() * 60);
+        if (updateRatio && updateRatio < 1.0) {
+            this.logger(`${updateRatio * 100.0}% of sectors updated in last 60 seconds.`);
+        }
+        const hostilePlayerNames = game
+            .getPlayers()
+            .map((name) => game.getPlayerData(name))
+            .filter((other) => other.name !== playerData.name &&
+            other.isCombatant &&
+            !game.areAlliedPlayers(playerData.name, other.name))
+            .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);
+        try {
+            const hostileUnits = hostileUnitIds
+                .map((id) => game.getUnitData(id))
+                .filter((unit) => this.isHostileUnit(unit, hostilePlayerNames));
+            rebuildQuadtree(this.hostileQuadTree, hostileUnits);
+        }
+        catch (err) {
+            // Hack. Will be fixed soon.
+            console.error(`caught error`, hostileUnitIds);
+        }
+        if (game.getCurrentTick() % THREAT_UPDATE_INTERVAL_TICKS == 0) {
+            let visibility = sectorCache?.getOverallVisibility();
+            if (visibility) {
+                this.logger(`${Math.round(visibility * 1000.0) / 10}% of tiles visible. Calculating threat.`);
+                // Update the global threat cache
+                this.threatCache = calculateGlobalThreat(game, playerData, visibility);
+                this.logger(`Threat LAND: Them ${Math.round(this.threatCache.totalOffensiveLandThreat)}, us: ${Math.round(this.threatCache.totalAvailableAntiGroundFirepower)}.`);
+                this.logger(`Threat DEFENSIVE: Them ${Math.round(this.threatCache.totalDefensiveThreat)}, us: ${Math.round(this.threatCache.totalDefensivePower)}.`);
+                this.logger(`Threat AIR: Them ${Math.round(this.threatCache.totalOffensiveAirThreat)}, us: ${Math.round(this.threatCache.totalAvailableAntiAirFirepower)}.`);
+                // As the game approaches 2 hours, be more willing to attack. (15 ticks per second)
+                const gameLengthFactor = Math.max(0, 1.0 - game.getCurrentTick() / (15 * 7200.0));
+                this.logger(`Game length multiplier: ${gameLengthFactor}`);
+                if (!this._shouldAttack) {
+                    // If not attacking, make it harder to switch to attack mode by multiplying the opponent's threat.
+                    this._shouldAttack = this.checkShouldAttack(this.threatCache, 1.25 * gameLengthFactor);
+                    if (this._shouldAttack) {
+                        this.logger(`Globally switched to attack mode.`);
+                    }
+                }
+                else {
+                    // If currently attacking, make it harder to switch to defence mode my dampening the opponent's threat.
+                    this._shouldAttack = this.checkShouldAttack(this.threatCache, 0.75 * gameLengthFactor);
+                    if (!this._shouldAttack) {
+                        this.logger(`Globally switched to defence mode.`);
+                    }
+                }
+            }
+        }
+        // Update rally point every few ticks.
+        if (game.getCurrentTick() % RALLY_POINT_UPDATE_INTERVAL_TICKS === 0) {
+            const enemyPlayers = game
+                .getPlayers()
+                .filter((p) => p !== playerData.name && !game.areAlliedPlayers(playerData.name, p));
+            const enemy = game.getPlayerData(enemyPlayers[0]);
+            this.mainRallyPoint = getPointTowardsOtherPoint(game, playerData.startLocation, enemy.startLocation, 10, 10, 0);
+        }
+    }
+}

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

@@ -11,8 +11,9 @@ export class BasicGroundUnit {
         return undefined;
     }
     getPriority(game, playerData, technoRules, threatCache) {
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
         if (threatCache) {
-            let priority = 1;
+            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) {
@@ -25,10 +26,11 @@ export class BasicGroundUnit {
                 else {
                     // But also, if our power dwarfs the enemy, keep pressing the advantage.
                     priority +=
-                        this.antiGroundPower *
+                        (this.antiGroundPower *
                             this.basePriority *
                             Math.sqrt(threatCache.totalAvailableAntiGroundFirepower /
-                                Math.max(1, threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat));
+                                Math.max(1, threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat))) /
+                            (numOwned + 1);
                 }
             }
             if (this.antiAirPower > 0) {
@@ -40,15 +42,15 @@ export class BasicGroundUnit {
                 }
                 else {
                     priority +=
-                        this.antiAirPower *
+                        (this.antiAirPower *
                             this.basePriority *
                             Math.sqrt(threatCache.totalAvailableAntiAirFirepower /
-                                Math.max(1, threatCache.totalOffensiveAirThreat + threatCache.totalDefensiveThreat));
+                                Math.max(1, threatCache.totalOffensiveAirThreat + threatCache.totalDefensiveThreat))) /
+                            (numOwned + 1);
                 }
             }
             return priority;
         }
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
         return this.basePriority * (1.0 - numOwned / this.baseAmount);
     }
     getMaxCount(game, playerData, technoRules, threatCache) {

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

@@ -31,7 +31,6 @@ export function getDefaultPlacementLocation(game, playerData, startPoint, techno
             }
         }
     }
-    console.log("Can't find a place to put the " + technoRules.name);
     return undefined;
 }
 export const DEFAULT_BUILDING_PRIORITY = 1;
@@ -45,14 +44,16 @@ export const BUILDING_NAME_TO_RULES = new Map([
     ["ENGINEER", new BasicBuilding(1, 1, 10000)],
     ["GADEPT", new BasicBuilding(1, 1, 10000)],
     ["GAAIRC", new BasicBuilding(8, 1, 6000)],
+    ["GATECH", new BasicBuilding(20, 1, 4000)],
     ["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)],
+    ["E1", new BasicGroundUnit(2, 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)],
+    ["ORCA", new BasicAirUnit(7, 1, 2, 0)],
     ["SREF", new ArtilleryUnit(9, 1)],
     ["CLEG", new BasicGroundUnit(0, 0)],
     ["SHAD", new BasicGroundUnit(0, 0)],
@@ -65,10 +66,12 @@ export const BUILDING_NAME_TO_RULES = new Map([
     ["SENGINEER", new BasicBuilding(1, 1, 10000)],
     ["NADEPT", new BasicBuilding(1, 1, 10000)],
     ["NARADR", new BasicBuilding(8, 1, 4000)],
+    ["NANRCT", new PowerPlant()],
+    ["NATECH", new BasicBuilding(20, 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)],
+    ["E2", new BasicGroundUnit(2, 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)],

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

@@ -9,7 +9,7 @@ export class Harvester extends BasicGroundUnit {
     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;
+        const boost = harvesters < this.minNeeded ? 3 : 1;
         return this.basePriority * (refineries / Math.max(harvesters / IDEAL_HARVESTERS_PER_REFINERY, 1)) * boost;
     }
 }

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

@@ -26,16 +26,9 @@ export const queueTypeToName = (queue) => {
             return "Unknown";
     }
 };
-// Repair buildings at this ratio of the maxHitpoints.
-const REPAIR_HITPOINTS_RATIO = 0.9;
-// Don't repair buildings more often than this.
-const REPAIR_COOLDOWN_TICKS = 15;
 const DEBUG_BUILD_QUEUES = true;
 export class QueueController {
-    constructor(buildingIdToLastHitpoints = new Map(), buildingIdLastRepairedAtTick = new Map()) {
-        this.buildingIdToLastHitpoints = buildingIdToLastHitpoints;
-        this.buildingIdLastRepairedAtTick = buildingIdLastRepairedAtTick;
-    }
+    constructor() { }
     onAiUpdate(game, productionApi, actionsApi, playerData, threatCache, logger) {
         const decisions = QUEUES.map((queueType) => {
             const options = productionApi.getAvailableObjects(queueType);
@@ -54,27 +47,17 @@ export class QueueController {
             this.updateBuildQueue(game, productionApi, actionsApi, playerData, threatCache, decision.queue, decision.decision, totalWeightAcrossQueues, totalCostAcrossQueues, logger);
         });
         // Repair is simple - just repair everything that's damaged.
-        // Unfortunately there doesn't seem to be an API to determine if something is being repaired, so we have to remember it.
         game.getVisibleUnits(playerData.name, "self", (r) => r.repairable).forEach((unitId) => {
             const unit = game.getUnitData(unitId);
-            if (!unit || !unit.hitPoints || !unit.maxHitPoints) {
+            if (!unit || !unit.hitPoints || !unit.maxHitPoints || unit.hasWrenchRepair) {
                 return;
             }
-            const lastKnownHitpoints = this.buildingIdToLastHitpoints.get(unitId) || unit.hitPoints;
-            const buildingLastRepairedAt = this.buildingIdLastRepairedAtTick.get(unitId) || 0;
-            // Only repair if HP is going down and if we haven't recently repaired it
-            if (unit.hitPoints <= lastKnownHitpoints &&
-                game.getCurrentTick() > buildingLastRepairedAt + REPAIR_COOLDOWN_TICKS &&
-                unit.hitPoints < unit.maxHitPoints * REPAIR_HITPOINTS_RATIO) {
-                actionsApi.toggleRepairWrench(unitId);
-                this.buildingIdLastRepairedAtTick.set(unitId, game.getCurrentTick());
-            }
-            this.buildingIdToLastHitpoints.set(unitId, unit.hitPoints);
+            actionsApi.toggleRepairWrench(unitId);
         });
     }
     updateBuildQueue(game, productionApi, actionsApi, playerData, threatCache, queueType, decision, totalWeightAcrossQueues, totalCostAcrossQueues, logger) {
         const myCredits = playerData.credits;
-        let queueData = productionApi.getQueueData(queueType);
+        const queueData = productionApi.getQueueData(queueType);
         if (queueData.status == QueueStatus.Idle) {
             // Start building the decided item.
             if (decision !== undefined) {