@supalosa/chronodivide-bot 0.5.4 → 0.6.6-beta.1

package/dist/bot/logic/awareness.js

@@ -1,137 +1,137 @@
-import { Vector2 } from "@chronodivide/game-api";
-import { calculateGlobalThreat } from "./threat/threatCalculator.js";
-import { getPointTowardsOtherPoint } from "./map/map.js";
-import { Circle, Quadtree } from "@timohausmann/quadtree-ts";
-import { ScoutingManager } from "./common/scout.js";
-const SECTORS_TO_UPDATE_PER_CYCLE = 8;
-const RALLY_POINT_UPDATE_INTERVAL_TICKS = 90;
-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 { width, height } = sectorCache.getMapBounds();
-        this.hostileQuadTree = new Quadtree({ width, height });
-        this.scoutingManager = new ScoutingManager(logger);
-    }
-    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 }) => new Vector2(x, y).distanceTo(new Vector2(searchX, searchY)) <= radius)
-            .filter(({ unitId }) => !!unitId);
-    }
-    getThreatCache() {
-        return this.threatCache;
-    }
-    getSectorCache() {
-        return this.sectorCache;
-    }
-    getMainRallyPoint() {
-        return this.mainRallyPoint;
-    }
-    getScoutingManager() {
-        return this.scoutingManager;
-    }
-    shouldAttack() {
-        return this._shouldAttack;
-    }
-    checkShouldAttack(threatCache, threatFactor) {
-        let scaledGroundPower = threatCache.totalAvailableAntiGroundFirepower * 1.1;
-        let scaledGroundThreat = (threatFactor * threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat) * 1.1;
-        let scaledAirPower = threatCache.totalAvailableAirPower * 1.1;
-        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);
-    }
-    onGameStart(gameApi, playerData) {
-        this.scoutingManager.onGameStart(gameApi, playerData, this.sectorCache);
-    }
-    onAiUpdate(game, playerData) {
-        const sectorCache = this.sectorCache;
-        sectorCache.updateSectors(game.getCurrentTick(), SECTORS_TO_UPDATE_PER_CYCLE, game.mapApi, playerData);
-        this.scoutingManager.onAiUpdate(game, playerData, sectorCache);
-        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, "enemy");
-        try {
-            const hostileUnits = hostileUnitIds
-                .map((id) => game.getGameObjectData(id))
-                .filter((gameObjectData) => gameObjectData !== undefined);
-            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);
-                // 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);
-        }
-    }
-    getGlobalDebugText() {
-        if (!this.threatCache) {
-            return undefined;
-        }
-        return (`Threat LAND: Them ${Math.round(this.threatCache.totalOffensiveLandThreat)}, us: ${Math.round(this.threatCache.totalAvailableAntiGroundFirepower)}.\n` +
-            `Threat DEFENSIVE: Them ${Math.round(this.threatCache.totalDefensiveThreat)}, us: ${Math.round(this.threatCache.totalDefensivePower)}.\n` +
-            `Threat AIR: Them ${Math.round(this.threatCache.totalOffensiveAirThreat)}, us: ${Math.round(this.threatCache.totalAvailableAntiAirFirepower)}.`);
-    }
-}
+import { Vector2 } from "@chronodivide/game-api";
+import { calculateGlobalThreat } from "./threat/threatCalculator.js";
+import { getPointTowardsOtherPoint } from "./map/map.js";
+import { Circle, Quadtree } from "@timohausmann/quadtree-ts";
+import { ScoutingManager } from "./common/scout.js";
+const SECTORS_TO_UPDATE_PER_CYCLE = 8;
+const RALLY_POINT_UPDATE_INTERVAL_TICKS = 90;
+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 { width, height } = sectorCache.getMapBounds();
+        this.hostileQuadTree = new Quadtree({ width, height });
+        this.scoutingManager = new ScoutingManager(logger);
+    }
+    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 }) => new Vector2(x, y).distanceTo(new Vector2(searchX, searchY)) <= radius)
+            .filter(({ unitId }) => !!unitId);
+    }
+    getThreatCache() {
+        return this.threatCache;
+    }
+    getSectorCache() {
+        return this.sectorCache;
+    }
+    getMainRallyPoint() {
+        return this.mainRallyPoint;
+    }
+    getScoutingManager() {
+        return this.scoutingManager;
+    }
+    shouldAttack() {
+        return this._shouldAttack;
+    }
+    checkShouldAttack(threatCache, threatFactor) {
+        let scaledGroundPower = threatCache.totalAvailableAntiGroundFirepower * 1.1;
+        let scaledGroundThreat = (threatFactor * threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat) * 1.1;
+        let scaledAirPower = threatCache.totalAvailableAirPower * 1.1;
+        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);
+    }
+    onGameStart(gameApi, playerData) {
+        this.scoutingManager.onGameStart(gameApi, playerData, this.sectorCache);
+    }
+    onAiUpdate(game, playerData) {
+        const sectorCache = this.sectorCache;
+        sectorCache.updateSectors(game.getCurrentTick(), SECTORS_TO_UPDATE_PER_CYCLE, game.mapApi, playerData);
+        this.scoutingManager.onAiUpdate(game, playerData, sectorCache);
+        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, "enemy");
+        try {
+            const hostileUnits = hostileUnitIds
+                .map((id) => game.getGameObjectData(id))
+                .filter((gameObjectData) => gameObjectData !== undefined);
+            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);
+                // 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);
+        }
+    }
+    getGlobalDebugText() {
+        if (!this.threatCache) {
+            return undefined;
+        }
+        return (`Threat LAND: Them ${Math.round(this.threatCache.totalOffensiveLandThreat)}, us: ${Math.round(this.threatCache.totalAvailableAntiGroundFirepower)}.\n` +
+            `Threat DEFENSIVE: Them ${Math.round(this.threatCache.totalDefensiveThreat)}, us: ${Math.round(this.threatCache.totalDefensivePower)}.\n` +
+            `Threat AIR: Them ${Math.round(this.threatCache.totalOffensiveAirThreat)}, us: ${Math.round(this.threatCache.totalAvailableAntiAirFirepower)}.`);
+    }
+}
 //# sourceMappingURL=awareness.js.map

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

@@ -1,43 +1,43 @@
-import { getPointTowardsOtherPoint } from "../map/map.js";
-import { getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
-export class AntiAirStaticDefence {
-    constructor(basePriority, baseAmount, airStrength) {
-        this.basePriority = basePriority;
-        this.baseAmount = baseAmount;
-        this.airStrength = airStrength;
-    }
-    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, false, 0);
-    }
-    getPriority(game, playerData, technoRules, threatCache) {
-        if (threatCache) {
-            let denominator = threatCache.totalAvailableAntiAirFirepower + this.airStrength;
-            if (threatCache.totalOffensiveAirThreat > denominator * 1.1) {
-                return this.basePriority * (threatCache.totalOffensiveAirThreat / Math.max(1, denominator));
-            }
-            else {
-                return 0;
-            }
-        }
-        const strengthPerCost = (this.airStrength / technoRules.cost) * 1000;
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        return this.basePriority * (1.0 - numOwned / this.baseAmount) * strengthPerCost;
-    }
-    getMaxCount(game, playerData, technoRules, threatCache) {
-        return null;
-    }
-}
+import { getPointTowardsOtherPoint } from "../map/map.js";
+import { getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
+export class AntiAirStaticDefence {
+    constructor(basePriority, baseAmount, airStrength) {
+        this.basePriority = basePriority;
+        this.baseAmount = baseAmount;
+        this.airStrength = airStrength;
+    }
+    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, false, 0);
+    }
+    getPriority(game, playerData, technoRules, threatCache) {
+        if (threatCache) {
+            let denominator = threatCache.totalAvailableAntiAirFirepower + this.airStrength;
+            if (threatCache.totalOffensiveAirThreat > denominator * 1.1) {
+                return this.basePriority * (threatCache.totalOffensiveAirThreat / Math.max(1, denominator));
+            }
+            else {
+                return 0;
+            }
+        }
+        const strengthPerCost = (this.airStrength / technoRules.cost) * 1000;
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        return this.basePriority * (1.0 - numOwned / this.baseAmount) * strengthPerCost;
+    }
+    getMaxCount(game, playerData, technoRules, threatCache) {
+        return null;
+    }
+}
 //# sourceMappingURL=antiAirStaticDefence.js.map

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

@@ -1,35 +1,35 @@
-import { numBuildingsOwnedOfType } from "./buildingRules.js";
-import { getStaticDefencePlacement } from "./common.js";
-export class AntiGroundStaticDefence {
-    constructor(basePriority, baseAmount, groundStrength, limit) {
-        this.basePriority = basePriority;
-        this.baseAmount = baseAmount;
-        this.groundStrength = groundStrength;
-        this.limit = limit;
-    }
-    getPlacementLocation(game, playerData, technoRules) {
-        return getStaticDefencePlacement(game, playerData, technoRules);
-    }
-    getPriority(game, playerData, technoRules, threatCache) {
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        if (numOwned >= this.limit) {
-            return 0;
-        }
-        // If the enemy's ground power is increasing we should try to keep up.
-        if (threatCache) {
-            let denominator = threatCache.totalAvailableAntiGroundFirepower + threatCache.totalDefensivePower + this.groundStrength;
-            if (threatCache.totalOffensiveLandThreat > denominator * 1.1) {
-                return this.basePriority * (threatCache.totalOffensiveLandThreat / Math.max(1, denominator));
-            }
-            else {
-                return 0;
-            }
-        }
-        const strengthPerCost = (this.groundStrength / technoRules.cost) * 1000;
-        return this.basePriority * (1.0 - numOwned / this.baseAmount) * strengthPerCost;
-    }
-    getMaxCount(game, playerData, technoRules, threatCache) {
-        return null;
-    }
-}
+import { numBuildingsOwnedOfType } from "./buildingRules.js";
+import { getStaticDefencePlacement } from "./common.js";
+export class AntiGroundStaticDefence {
+    constructor(basePriority, baseAmount, groundStrength, limit) {
+        this.basePriority = basePriority;
+        this.baseAmount = baseAmount;
+        this.groundStrength = groundStrength;
+        this.limit = limit;
+    }
+    getPlacementLocation(game, playerData, technoRules) {
+        return getStaticDefencePlacement(game, playerData, technoRules);
+    }
+    getPriority(game, playerData, technoRules, threatCache) {
+        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
+        if (numOwned >= this.limit) {
+            return 0;
+        }
+        // If the enemy's ground power is increasing we should try to keep up.
+        if (threatCache) {
+            let denominator = threatCache.totalAvailableAntiGroundFirepower + threatCache.totalDefensivePower + this.groundStrength;
+            if (threatCache.totalOffensiveLandThreat > denominator * 1.1) {
+                return this.basePriority * (threatCache.totalOffensiveLandThreat / Math.max(1, denominator));
+            }
+            else {
+                return 0;
+            }
+        }
+        const strengthPerCost = (this.groundStrength / technoRules.cost) * 1000;
+        return this.basePriority * (1.0 - numOwned / this.baseAmount) * strengthPerCost;
+    }
+    getMaxCount(game, playerData, technoRules, threatCache) {
+        return null;
+    }
+}
 //# sourceMappingURL=antiGroundStaticDefence.js.map

package/dist/bot/logic/building/{ArtilleryUnit.js → artilleryUnit.js}

@@ -1,19 +1,19 @@
-export class ArtilleryUnit {
-    constructor(basePriority, artilleryPower, antiGroundPower, baseAmount) {
-        this.basePriority = basePriority;
-        this.artilleryPower = artilleryPower;
-        this.antiGroundPower = antiGroundPower;
-        this.baseAmount = baseAmount;
-    }
-    getPlacementLocation(game, playerData, technoRules) {
-        return undefined;
-    }
-    getPriority(game, playerData, technoRules, threatCache) {
-        // Units aren't built automatically, but are instead requested by missions.
-        return 0;
-    }
-    getMaxCount(game, playerData, technoRules, threatCache) {
-        return null;
-    }
-}
+export class ArtilleryUnit {
+    constructor(basePriority, artilleryPower, antiGroundPower, baseAmount) {
+        this.basePriority = basePriority;
+        this.artilleryPower = artilleryPower;
+        this.antiGroundPower = antiGroundPower;
+        this.baseAmount = baseAmount;
+    }
+    getPlacementLocation(game, playerData, technoRules) {
+        return undefined;
+    }
+    getPriority(game, playerData, technoRules, threatCache) {
+        // Units aren't built automatically, but are instead requested by missions.
+        return 0;
+    }
+    getMaxCount(game, playerData, technoRules, threatCache) {
+        return null;
+    }
+}
 //# sourceMappingURL=artilleryUnit.js.map

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

@@ -1,20 +1,20 @@
-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) {
-        // Units aren't built automatically, but are instead requested by missions.
-        return 0;
-    }
-    getMaxCount(game, playerData, technoRules, threatCache) {
-        return null;
-    }
-}
+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) {
+        // Units aren't built automatically, but are instead requested by missions.
+        return 0;
+    }
+    getMaxCount(game, playerData, technoRules, threatCache) {
+        return null;
+    }
+}
 //# sourceMappingURL=basicAirUnit.js.map

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

@@ -1,27 +1,27 @@
-import { getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.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;
-        }
-        const priority = this.basePriority * (1.0 - numOwned / this.maxNeeded);
-        if (this.onlyBuildWhenFloatingCreditsAmount && playerData.credits < this.onlyBuildWhenFloatingCreditsAmount) {
-            return priority * (playerData.credits / this.onlyBuildWhenFloatingCreditsAmount);
-        }
-        return priority;
-    }
-    getMaxCount(game, playerData, technoRules, threatCache) {
-        return this.maxNeeded;
-    }
-}
+import { getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.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;
+        }
+        const priority = this.basePriority * (1.0 - numOwned / this.maxNeeded);
+        if (this.onlyBuildWhenFloatingCreditsAmount && playerData.credits < this.onlyBuildWhenFloatingCreditsAmount) {
+            return priority * (playerData.credits / this.onlyBuildWhenFloatingCreditsAmount);
+        }
+        return priority;
+    }
+    getMaxCount(game, playerData, technoRules, threatCache) {
+        return this.maxNeeded;
+    }
+}
 //# sourceMappingURL=basicBuilding.js.map

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

@@ -1,20 +1,20 @@
-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) {
-        // Units aren't built automatically, but are instead requested by missions.
-        return 0;
-    }
-    getMaxCount(game, playerData, technoRules, threatCache) {
-        return null;
-    }
-}
+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) {
+        // Units aren't built automatically, but are instead requested by missions.
+        return 0;
+    }
+    getMaxCount(game, playerData, technoRules, threatCache) {
+        return null;
+    }
+}
 //# sourceMappingURL=basicGroundUnit.js.map