@supalosa/chronodivide-bot 0.5.4 → 0.6.4

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

@@ -1,176 +1,176 @@
-import { GameMath, LandType, ObjectType, Vector2, } from "@chronodivide/game-api";
-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";
-import { uniqBy } from "../common/utils.js";
-import { AntiAirStaticDefence } from "./antiAirStaticDefence.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;
-}
-/**
- * Computes a rect 'centered' around a structure of a certain size with an additional radius (`adjacent`).
- * The radius is optionally expanded by the size of the new building.
- *
- * This is essentially the candidate placement around a given structure.
- *
- * @param point Top-left location of the inner rect.
- * @param t Size of the inner rect.
- * @param adjacent Amount to expand the building's inner rect by (so buildings must be adjacent by this many tiles)
- * @param newBuildingSize? Size of the new building
- * @returns
- */
-function computeAdjacentRect(point, t, adjacent, newBuildingSize) {
-    return {
-        x: point.x - adjacent - (newBuildingSize?.width || 0),
-        y: point.y - adjacent - (newBuildingSize?.height || 0),
-        width: t.width + 2 * adjacent + (newBuildingSize?.width || 0),
-        height: t.height + 2 * adjacent + (newBuildingSize?.height || 0),
-    };
-}
-function getAdjacentTiles(game, range, onWater) {
-    // use the bulk API to get all tiles from the baseTile to the (baseTile + range)
-    const adjacentTiles = game.mapApi
-        .getTilesInRect(range)
-        .filter((tile) => !onWater || tile.landType === LandType.Water);
-    return adjacentTiles;
-}
-export function getAdjacencyTiles(game, playerData, technoRules, onWater, minimumSpace) {
-    const placementRules = game.getBuildingPlacementData(technoRules.name);
-    const { width: newBuildingWidth, height: newBuildingHeight } = placementRules.foundation;
-    const tiles = [];
-    const buildings = game.getVisibleUnits(playerData.name, "self", (r) => r.type === ObjectType.Building);
-    const removedTiles = new Set();
-    for (let buildingId of buildings) {
-        const building = game.getUnitData(buildingId);
-        if (!building?.rules?.baseNormal) {
-            // This building is not considered for adjacency checks.
-            continue;
-        }
-        const { foundation, tile } = building;
-        const buildingBase = new Vector2(tile.rx, tile.ry);
-        const buildingSize = {
-            width: foundation?.width,
-            height: foundation?.height,
-        };
-        const range = computeAdjacentRect(buildingBase, buildingSize, technoRules.adjacent, placementRules.foundation);
-        const adjacentTiles = getAdjacentTiles(game, range, onWater);
-        if (adjacentTiles.length === 0) {
-            continue;
-        }
-        tiles.push(...adjacentTiles);
-        // Prevent placing the new building on tiles that would cause it to overlap with this building.
-        const modifiedBase = new Vector2(buildingBase.x - (newBuildingWidth - 1), buildingBase.y - (newBuildingHeight - 1));
-        const modifiedSize = {
-            width: buildingSize.width + (newBuildingWidth - 1),
-            height: buildingSize.height + (newBuildingHeight - 1),
-        };
-        const blockedRect = computeAdjacentRect(modifiedBase, modifiedSize, minimumSpace);
-        const buildingTiles = adjacentTiles.filter((tile) => {
-            return (tile.rx >= blockedRect.x &&
-                tile.rx < blockedRect.x + blockedRect.width &&
-                tile.ry >= blockedRect.y &&
-                tile.ry < blockedRect.y + blockedRect.height);
-        });
-        buildingTiles.forEach((buildingTile) => removedTiles.add(buildingTile.id));
-    }
-    // Remove duplicate tiles.
-    const withDuplicatesRemoved = uniqBy(tiles, (tile) => tile.id);
-    // Remove tiles containing buildings and potentially area around them removed as well.
-    return withDuplicatesRemoved.filter((tile) => !removedTiles.has(tile.id));
-}
-function getTileDistances(startPoint, tiles) {
-    return tiles
-        .map((tile) => ({
-        tile,
-        distance: distance(tile.rx, tile.ry, startPoint.x, startPoint.y),
-    }))
-        .sort((a, b) => {
-        return a.distance - b.distance;
-    });
-}
-function distance(x1, y1, x2, y2) {
-    var dx = x1 - x2;
-    var dy = y1 - y2;
-    let tmp = dx * dx + dy * dy;
-    if (0 === tmp) {
-        return 0;
-    }
-    return GameMath.sqrt(tmp);
-}
-export function getDefaultPlacementLocation(game, playerData, idealPoint, technoRules, onWater = false, minSpace = 1) {
-    // Closest possible location near `startPoint`.
-    const size = game.getBuildingPlacementData(technoRules.name);
-    if (!size) {
-        return undefined;
-    }
-    const tiles = getAdjacencyTiles(game, playerData, technoRules, onWater, minSpace);
-    const tileDistances = getTileDistances(idealPoint, tiles);
-    for (let tileDistance of tileDistances) {
-        if (tileDistance.tile && game.canPlaceBuilding(playerData.name, technoRules.name, tileDistance.tile)) {
-            return tileDistance.tile;
-        }
-    }
-    return undefined;
-}
-export const DEFAULT_BUILDING_PRIORITY = 0;
-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)],
-    ["GADEPT", new BasicBuilding(1, 1, 10000)],
-    ["GAAIRC", new BasicBuilding(10, 1, 500)],
-    ["AMRADR", new BasicBuilding(10, 1, 500)],
-    ["GATECH", new BasicBuilding(20, 1, 4000)],
-    ["GAYARD", new BasicBuilding(0, 0, 0)],
-    ["GAPILL", new AntiGroundStaticDefence(2, 1, 5, 5)],
-    ["ATESLA", new AntiGroundStaticDefence(2, 1, 10, 3)],
-    ["NASAM", new AntiAirStaticDefence(2, 1, 5)],
-    ["GAWALL", new AntiGroundStaticDefence(0, 0, 0, 0)],
-    ["E1", new BasicGroundUnit(2, 2, 0.2, 0)],
-    ["ENGINEER", new BasicGroundUnit(1, 0, 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(10, 5, 3, 3)],
-    ["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)],
-    ["NADEPT", new BasicBuilding(1, 1, 10000)],
-    ["NARADR", new BasicBuilding(10, 1, 500)],
-    ["NANRCT", new PowerPlant()],
-    ["NAYARD", new BasicBuilding(0, 0, 0)],
-    ["NATECH", new BasicBuilding(20, 1, 4000)],
-    ["NALASR", new AntiGroundStaticDefence(2, 1, 5, 5)],
-    ["NAFLAK", new AntiAirStaticDefence(2, 1, 5)],
-    ["TESLA", new AntiGroundStaticDefence(2, 1, 10, 3)],
-    ["NAWALL", new AntiGroundStaticDefence(0, 0, 0, 0)],
-    ["E2", new BasicGroundUnit(2, 2, 0.2, 0)],
-    ["SENGINEER", new BasicGroundUnit(1, 0, 0)],
-    ["FLAKT", new BasicGroundUnit(2, 2, 0.1, 0.3)],
-    ["YURI", new BasicGroundUnit(1, 1, 1, 0)],
-    ["DOG", new BasicGroundUnit(1, 1, 0, 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, 10, 0, 3)], // V3 Rocket Launcher
-]);
+import { GameMath, LandType, ObjectType, Vector2, } from "@chronodivide/game-api";
+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";
+import { uniqBy } from "../common/utils.js";
+import { AntiAirStaticDefence } from "./antiAirStaticDefence.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;
+}
+/**
+ * Computes a rect 'centered' around a structure of a certain size with an additional radius (`adjacent`).
+ * The radius is optionally expanded by the size of the new building.
+ *
+ * This is essentially the candidate placement around a given structure.
+ *
+ * @param point Top-left location of the inner rect.
+ * @param t Size of the inner rect.
+ * @param adjacent Amount to expand the building's inner rect by (so buildings must be adjacent by this many tiles)
+ * @param newBuildingSize? Size of the new building
+ * @returns
+ */
+function computeAdjacentRect(point, t, adjacent, newBuildingSize) {
+    return {
+        x: point.x - adjacent - (newBuildingSize?.width || 0),
+        y: point.y - adjacent - (newBuildingSize?.height || 0),
+        width: t.width + 2 * adjacent + (newBuildingSize?.width || 0),
+        height: t.height + 2 * adjacent + (newBuildingSize?.height || 0),
+    };
+}
+function getAdjacentTiles(game, range, onWater) {
+    // use the bulk API to get all tiles from the baseTile to the (baseTile + range)
+    const adjacentTiles = game.mapApi
+        .getTilesInRect(range)
+        .filter((tile) => !onWater || tile.landType === LandType.Water);
+    return adjacentTiles;
+}
+export function getAdjacencyTiles(game, playerData, technoRules, onWater, minimumSpace) {
+    const placementRules = game.getBuildingPlacementData(technoRules.name);
+    const { width: newBuildingWidth, height: newBuildingHeight } = placementRules.foundation;
+    const tiles = [];
+    const buildings = game.getVisibleUnits(playerData.name, "self", (r) => r.type === ObjectType.Building);
+    const removedTiles = new Set();
+    for (let buildingId of buildings) {
+        const building = game.getUnitData(buildingId);
+        if (!building?.rules?.baseNormal) {
+            // This building is not considered for adjacency checks.
+            continue;
+        }
+        const { foundation, tile } = building;
+        const buildingBase = new Vector2(tile.rx, tile.ry);
+        const buildingSize = {
+            width: foundation?.width,
+            height: foundation?.height,
+        };
+        const range = computeAdjacentRect(buildingBase, buildingSize, technoRules.adjacent, placementRules.foundation);
+        const adjacentTiles = getAdjacentTiles(game, range, onWater);
+        if (adjacentTiles.length === 0) {
+            continue;
+        }
+        tiles.push(...adjacentTiles);
+        // Prevent placing the new building on tiles that would cause it to overlap with this building.
+        const modifiedBase = new Vector2(buildingBase.x - (newBuildingWidth - 1), buildingBase.y - (newBuildingHeight - 1));
+        const modifiedSize = {
+            width: buildingSize.width + (newBuildingWidth - 1),
+            height: buildingSize.height + (newBuildingHeight - 1),
+        };
+        const blockedRect = computeAdjacentRect(modifiedBase, modifiedSize, minimumSpace);
+        const buildingTiles = adjacentTiles.filter((tile) => {
+            return (tile.rx >= blockedRect.x &&
+                tile.rx < blockedRect.x + blockedRect.width &&
+                tile.ry >= blockedRect.y &&
+                tile.ry < blockedRect.y + blockedRect.height);
+        });
+        buildingTiles.forEach((buildingTile) => removedTiles.add(buildingTile.id));
+    }
+    // Remove duplicate tiles.
+    const withDuplicatesRemoved = uniqBy(tiles, (tile) => tile.id);
+    // Remove tiles containing buildings and potentially area around them removed as well.
+    return withDuplicatesRemoved.filter((tile) => !removedTiles.has(tile.id));
+}
+function getTileDistances(startPoint, tiles) {
+    return tiles
+        .map((tile) => ({
+        tile,
+        distance: distance(tile.rx, tile.ry, startPoint.x, startPoint.y),
+    }))
+        .sort((a, b) => {
+        return a.distance - b.distance;
+    });
+}
+function distance(x1, y1, x2, y2) {
+    var dx = x1 - x2;
+    var dy = y1 - y2;
+    let tmp = dx * dx + dy * dy;
+    if (0 === tmp) {
+        return 0;
+    }
+    return GameMath.sqrt(tmp);
+}
+export function getDefaultPlacementLocation(game, playerData, idealPoint, technoRules, onWater = false, minSpace = 1) {
+    // Closest possible location near `startPoint`.
+    const size = game.getBuildingPlacementData(technoRules.name);
+    if (!size) {
+        return undefined;
+    }
+    const tiles = getAdjacencyTiles(game, playerData, technoRules, onWater, minSpace);
+    const tileDistances = getTileDistances(idealPoint, tiles);
+    for (let tileDistance of tileDistances) {
+        if (tileDistance.tile && game.canPlaceBuilding(playerData.name, technoRules.name, tileDistance.tile)) {
+            return tileDistance.tile;
+        }
+    }
+    return undefined;
+}
+export const DEFAULT_BUILDING_PRIORITY = 0;
+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)],
+    ["GADEPT", new BasicBuilding(1, 1, 10000)],
+    ["GAAIRC", new BasicBuilding(10, 1, 500)],
+    ["AMRADR", new BasicBuilding(10, 1, 500)],
+    ["GATECH", new BasicBuilding(20, 1, 4000)],
+    ["GAYARD", new BasicBuilding(0, 0, 0)],
+    ["GAPILL", new AntiGroundStaticDefence(2, 1, 5, 5)],
+    ["ATESLA", new AntiGroundStaticDefence(2, 1, 10, 3)],
+    ["NASAM", new AntiAirStaticDefence(2, 1, 5)],
+    ["GAWALL", new AntiGroundStaticDefence(0, 0, 0, 0)],
+    ["E1", new BasicGroundUnit(2, 2, 0.2, 0)],
+    ["ENGINEER", new BasicGroundUnit(1, 0, 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(10, 5, 3, 3)],
+    ["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)],
+    ["NADEPT", new BasicBuilding(1, 1, 10000)],
+    ["NARADR", new BasicBuilding(10, 1, 500)],
+    ["NANRCT", new PowerPlant()],
+    ["NAYARD", new BasicBuilding(0, 0, 0)],
+    ["NATECH", new BasicBuilding(20, 1, 4000)],
+    ["NALASR", new AntiGroundStaticDefence(2, 1, 5, 5)],
+    ["NAFLAK", new AntiAirStaticDefence(2, 1, 5)],
+    ["TESLA", new AntiGroundStaticDefence(2, 1, 10, 3)],
+    ["NAWALL", new AntiGroundStaticDefence(0, 0, 0, 0)],
+    ["E2", new BasicGroundUnit(2, 2, 0.2, 0)],
+    ["SENGINEER", new BasicGroundUnit(1, 0, 0)],
+    ["FLAKT", new BasicGroundUnit(2, 2, 0.1, 0.3)],
+    ["YURI", new BasicGroundUnit(1, 1, 1, 0)],
+    ["DOG", new BasicGroundUnit(1, 1, 0, 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, 10, 0, 3)], // V3 Rocket Launcher
+]);
 //# sourceMappingURL=buildingRules.js.map

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

@@ -1,20 +1,20 @@
-import { getPointTowardsOtherPoint } from "../map/map.js";
-import { getDefaultPlacementLocation } from "./buildingRules.js";
-export const getStaticDefencePlacement = (game, playerData, technoRules) => {
-    // Prefer front towards enemy.
-    const { startLocation, name: currentName } = playerData;
-    const allNames = game.getPlayers();
-    // Create a list of positions that point roughly towards hostile player start locatoins.
-    const candidates = allNames
-        .filter((otherName) => otherName !== currentName && !game.areAlliedPlayers(otherName, currentName))
-        .map((otherName) => {
-        const enemyPlayer = game.getPlayerData(otherName);
-        return getPointTowardsOtherPoint(game, startLocation, enemyPlayer.startLocation, 4, 16, 1.5);
-    });
-    if (candidates.length === 0) {
-        return undefined;
-    }
-    const selectedLocation = candidates[Math.floor(game.generateRandom() * candidates.length)];
-    return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules, false, 2);
-};
+import { getPointTowardsOtherPoint } from "../map/map.js";
+import { getDefaultPlacementLocation } from "./buildingRules.js";
+export const getStaticDefencePlacement = (game, playerData, technoRules) => {
+    // Prefer front towards enemy.
+    const { startLocation, name: currentName } = playerData;
+    const allNames = game.getPlayers();
+    // Create a list of positions that point roughly towards hostile player start locatoins.
+    const candidates = allNames
+        .filter((otherName) => otherName !== currentName && !game.areAlliedPlayers(otherName, currentName))
+        .map((otherName) => {
+        const enemyPlayer = game.getPlayerData(otherName);
+        return getPointTowardsOtherPoint(game, startLocation, enemyPlayer.startLocation, 4, 16, 1.5);
+    });
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    const selectedLocation = candidates[Math.floor(game.generateRandom() * candidates.length)];
+    return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules, false, 2);
+};
 //# sourceMappingURL=common.js.map

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

@@ -1,17 +1,17 @@
-import { BasicGroundUnit } from "./basicGroundUnit.js";
-const IDEAL_HARVESTERS_PER_REFINERY = 2;
-const MAX_HARVESTERS_PER_REFINERY = 4;
-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 ? 3 : harvesters > refineries * MAX_HARVESTERS_PER_REFINERY ? 0 : 1;
-        return this.basePriority * (refineries / Math.max(harvesters / IDEAL_HARVESTERS_PER_REFINERY, 1)) * boost;
-    }
-}
+import { BasicGroundUnit } from "./basicGroundUnit.js";
+const IDEAL_HARVESTERS_PER_REFINERY = 2;
+const MAX_HARVESTERS_PER_REFINERY = 4;
+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 ? 3 : harvesters > refineries * MAX_HARVESTERS_PER_REFINERY ? 0 : 1;
+        return this.basePriority * (refineries / Math.max(harvesters / IDEAL_HARVESTERS_PER_REFINERY, 1)) * boost;
+    }
+}
 //# sourceMappingURL=harvester.js.map

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

@@ -1,21 +1,21 @@
-import { getDefaultPlacementLocation } from "./buildingRules.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;
-    }
-}
+import { getDefaultPlacementLocation } from "./buildingRules.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;
+    }
+}
 //# sourceMappingURL=powerPlant.js.map