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

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

@@ -1,184 +1,184 @@
-import { QueueStatus, QueueType, } from "@chronodivide/game-api";
-import { BUILDING_NAME_TO_RULES, DEFAULT_BUILDING_PRIORITY, getDefaultPlacementLocation, } from "./buildingRules.js";
-export const QUEUES = [
-    QueueType.Structures,
-    QueueType.Armory,
-    QueueType.Infantry,
-    QueueType.Vehicles,
-    QueueType.Aircrafts,
-    QueueType.Ships,
-];
-export const queueTypeToName = (queue) => {
-    switch (queue) {
-        case QueueType.Structures:
-            return "Structures";
-        case QueueType.Armory:
-            return "Armory";
-        case QueueType.Infantry:
-            return "Infantry";
-        case QueueType.Vehicles:
-            return "Vehicles";
-        case QueueType.Aircrafts:
-            return "Aircrafts";
-        case QueueType.Ships:
-            return "Ships";
-        default:
-            return "Unknown";
-    }
-};
-export class QueueController {
-    constructor() {
-        this.queueStates = [];
-    }
-    onAiUpdate(game, productionApi, actionsApi, playerData, threatCache, unitTypeRequests, logger) {
-        this.queueStates = QUEUES.map((queueType) => {
-            const options = productionApi.getAvailableObjects(queueType);
-            const items = this.getPrioritiesForBuildingOptions(game, options, threatCache, playerData, unitTypeRequests, logger);
-            const topItem = items.length > 0 ? items[items.length - 1] : undefined;
-            return {
-                queue: queueType,
-                items,
-                // only if the top item has a  priority above zero
-                topItem: topItem && topItem.priority > 0 ? topItem : undefined,
-            };
-        });
-        const totalWeightAcrossQueues = this.queueStates
-            .map((decision) => decision.topItem?.priority)
-            .reduce((pV, cV) => pV + cV, 0);
-        const totalCostAcrossQueues = this.queueStates
-            .map((decision) => decision.topItem?.unit.cost)
-            .reduce((pV, cV) => pV + cV, 0);
-        this.queueStates.forEach((decision) => {
-            this.updateBuildQueue(game, productionApi, actionsApi, playerData, threatCache, decision.queue, decision.topItem, totalWeightAcrossQueues, totalCostAcrossQueues, logger);
-        });
-        // Repair is simple - just repair everything that's damaged.
-        if (playerData.credits > 0) {
-            game.getVisibleUnits(playerData.name, "self", (r) => r.repairable).forEach((unitId) => {
-                const unit = game.getUnitData(unitId);
-                if (!unit || !unit.hitPoints || !unit.maxHitPoints || unit.hasWrenchRepair) {
-                    return;
-                }
-                if (unit.hitPoints < unit.maxHitPoints) {
-                    actionsApi.toggleRepairWrench(unitId);
-                }
-            });
-        }
-    }
-    updateBuildQueue(game, productionApi, actionsApi, playerData, threatCache, queueType, decision, totalWeightAcrossQueues, totalCostAcrossQueues, logger) {
-        const myCredits = playerData.credits;
-        const queueData = productionApi.getQueueData(queueType);
-        if (queueData.status == QueueStatus.Idle) {
-            // Start building the decided item.
-            if (decision !== undefined) {
-                logger(`Decision (${queueTypeToName(queueType)}): ${decision.unit.name}`);
-                actionsApi.queueForProduction(queueType, decision.unit.name, decision.unit.type, 1);
-            }
-        }
-        else if (queueData.status == QueueStatus.Ready && queueData.items.length > 0) {
-            // Consider placing it.
-            const objectReady = queueData.items[0].rules;
-            if (queueType == QueueType.Structures || queueType == QueueType.Armory) {
-                let location = this.getBestLocationForStructure(game, playerData, objectReady);
-                if (location !== undefined) {
-                    logger(`Completed: ${queueTypeToName(queueType)}: ${objectReady.name}, placing at ${location.rx},${location.ry}`);
-                    actionsApi.placeBuilding(objectReady.name, location.rx, location.ry);
-                }
-                else {
-                    logger(`Completed: ${queueTypeToName(queueType)}: ${objectReady.name} but nowhere to place it`);
-                }
-            }
-        }
-        else if (queueData.status == QueueStatus.Active && queueData.items.length > 0 && decision != null) {
-            // Consider cancelling if something else is significantly higher priority than what is currently being produced.
-            const currentProduction = queueData.items[0].rules;
-            if (decision.unit != currentProduction) {
-                // Changing our mind.
-                let currentItemPriority = this.getPriorityForBuildingOption(currentProduction, game, playerData, threatCache);
-                let newItemPriority = decision.priority;
-                if (newItemPriority > currentItemPriority * 2) {
-                    logger(`Dequeueing queue ${queueTypeToName(queueData.type)} unit ${currentProduction.name} because ${decision.unit.name} has 2x higher priority.`);
-                    actionsApi.unqueueFromProduction(queueData.type, currentProduction.name, currentProduction.type, 1);
-                }
-            }
-            else {
-                // Not changing our mind, but maybe other queues are more important for now.
-                if (totalCostAcrossQueues > myCredits && decision.priority < totalWeightAcrossQueues * 0.25) {
-                    logger(`Pausing queue ${queueTypeToName(queueData.type)} because weight is low (${decision.priority}/${totalWeightAcrossQueues})`);
-                    actionsApi.pauseProduction(queueData.type);
-                }
-            }
-        }
-        else if (queueData.status == QueueStatus.OnHold) {
-            // Consider resuming queue if priority is high relative to other queues.
-            if (myCredits >= totalCostAcrossQueues) {
-                logger(`Resuming queue ${queueTypeToName(queueData.type)} because credits are high`);
-                actionsApi.resumeProduction(queueData.type);
-            }
-            else if (decision && decision.priority >= totalWeightAcrossQueues * 0.25) {
-                logger(`Resuming queue ${queueTypeToName(queueData.type)} because weight is high (${decision.priority}/${totalWeightAcrossQueues})`);
-                actionsApi.resumeProduction(queueData.type);
-            }
-        }
-    }
-    getPrioritiesForBuildingOptions(game, options, threatCache, playerData, unitTypeRequests, logger) {
-        let priorityQueue = [];
-        options.forEach((option) => {
-            const calculatedPriority = this.getPriorityForBuildingOption(option, game, playerData, threatCache);
-            // Get the higher of the dynamic and the mission priority for the unit.
-            const actualPriority = Math.max(calculatedPriority, unitTypeRequests.get(option.name) ?? calculatedPriority);
-            if (actualPriority > 0) {
-                priorityQueue.push({ unit: option, priority: actualPriority });
-            }
-        });
-        priorityQueue = priorityQueue.sort((a, b) => a.priority - b.priority);
-        return priorityQueue;
-    }
-    getPriorityForBuildingOption(option, game, playerStatus, threatCache) {
-        if (BUILDING_NAME_TO_RULES.has(option.name)) {
-            let logic = BUILDING_NAME_TO_RULES.get(option.name);
-            return logic.getPriority(game, playerStatus, option, threatCache);
-        }
-        else {
-            // Fallback priority when there are no rules.
-            return (DEFAULT_BUILDING_PRIORITY - game.getVisibleUnits(playerStatus.name, "self", (r) => r == option).length);
-        }
-    }
-    getBestLocationForStructure(game, playerData, objectReady) {
-        if (BUILDING_NAME_TO_RULES.has(objectReady.name)) {
-            let logic = BUILDING_NAME_TO_RULES.get(objectReady.name);
-            return logic.getPlacementLocation(game, playerData, objectReady);
-        }
-        else {
-            // fallback placement logic
-            return getDefaultPlacementLocation(game, playerData, playerData.startLocation, objectReady);
-        }
-    }
-    getGlobalDebugText(gameApi, productionApi) {
-        const productionState = QUEUES.reduce((prev, queueType) => {
-            if (productionApi.getQueueData(queueType).size === 0) {
-                return prev;
-            }
-            const paused = productionApi.getQueueData(queueType).status === QueueStatus.OnHold;
-            return (prev +
-                " [" +
-                queueTypeToName(queueType) +
-                (paused ? " PAUSED" : "") +
-                ": " +
-                productionApi
-                    .getQueueData(queueType)
-                    .items.map((item) => item.rules.name + (item.quantity > 1 ? "x" + item.quantity : "")) +
-                "]");
-        }, "");
-        const queueStates = this.queueStates
-            .filter((queueState) => queueState.items.length > 0)
-            .map((queueState) => {
-            const queueString = queueState.items
-                .map((item) => item.unit.name + "(" + Math.round(item.priority * 10) / 10 + ")")
-                .join(", ");
-            return `${queueTypeToName(queueState.queue)} Prios: ${queueString}\n`;
-        })
-            .join("");
-        return `Production: ${productionState}\n${queueStates}`;
-    }
-}
+import { QueueStatus, QueueType, } from "@chronodivide/game-api";
+import { BUILDING_NAME_TO_RULES, DEFAULT_BUILDING_PRIORITY, getDefaultPlacementLocation, } from "./buildingRules.js";
+export const QUEUES = [
+    QueueType.Structures,
+    QueueType.Armory,
+    QueueType.Infantry,
+    QueueType.Vehicles,
+    QueueType.Aircrafts,
+    QueueType.Ships,
+];
+export const queueTypeToName = (queue) => {
+    switch (queue) {
+        case QueueType.Structures:
+            return "Structures";
+        case QueueType.Armory:
+            return "Armory";
+        case QueueType.Infantry:
+            return "Infantry";
+        case QueueType.Vehicles:
+            return "Vehicles";
+        case QueueType.Aircrafts:
+            return "Aircrafts";
+        case QueueType.Ships:
+            return "Ships";
+        default:
+            return "Unknown";
+    }
+};
+export class QueueController {
+    constructor() {
+        this.queueStates = [];
+    }
+    onAiUpdate(game, productionApi, actionsApi, playerData, threatCache, unitTypeRequests, logger) {
+        this.queueStates = QUEUES.map((queueType) => {
+            const options = productionApi.getAvailableObjects(queueType);
+            const items = this.getPrioritiesForBuildingOptions(game, options, threatCache, playerData, unitTypeRequests, logger);
+            const topItem = items.length > 0 ? items[items.length - 1] : undefined;
+            return {
+                queue: queueType,
+                items,
+                // only if the top item has a  priority above zero
+                topItem: topItem && topItem.priority > 0 ? topItem : undefined,
+            };
+        });
+        const totalWeightAcrossQueues = this.queueStates
+            .map((decision) => decision.topItem?.priority)
+            .reduce((pV, cV) => pV + cV, 0);
+        const totalCostAcrossQueues = this.queueStates
+            .map((decision) => decision.topItem?.unit.cost)
+            .reduce((pV, cV) => pV + cV, 0);
+        this.queueStates.forEach((decision) => {
+            this.updateBuildQueue(game, productionApi, actionsApi, playerData, threatCache, decision.queue, decision.topItem, totalWeightAcrossQueues, totalCostAcrossQueues, logger);
+        });
+        // Repair is simple - just repair everything that's damaged.
+        if (playerData.credits > 0) {
+            game.getVisibleUnits(playerData.name, "self", (r) => r.repairable).forEach((unitId) => {
+                const unit = game.getUnitData(unitId);
+                if (!unit || !unit.hitPoints || !unit.maxHitPoints || unit.hasWrenchRepair) {
+                    return;
+                }
+                if (unit.hitPoints < unit.maxHitPoints) {
+                    actionsApi.toggleRepairWrench(unitId);
+                }
+            });
+        }
+    }
+    updateBuildQueue(game, productionApi, actionsApi, playerData, threatCache, queueType, decision, totalWeightAcrossQueues, totalCostAcrossQueues, logger) {
+        const myCredits = playerData.credits;
+        const queueData = productionApi.getQueueData(queueType);
+        if (queueData.status == QueueStatus.Idle) {
+            // Start building the decided item.
+            if (decision !== undefined) {
+                logger(`Decision (${queueTypeToName(queueType)}): ${decision.unit.name}`);
+                actionsApi.queueForProduction(queueType, decision.unit.name, decision.unit.type, 1);
+            }
+        }
+        else if (queueData.status == QueueStatus.Ready && queueData.items.length > 0) {
+            // Consider placing it.
+            const objectReady = queueData.items[0].rules;
+            if (queueType == QueueType.Structures || queueType == QueueType.Armory) {
+                let location = this.getBestLocationForStructure(game, playerData, objectReady);
+                if (location !== undefined) {
+                    logger(`Completed: ${queueTypeToName(queueType)}: ${objectReady.name}, placing at ${location.rx},${location.ry}`);
+                    actionsApi.placeBuilding(objectReady.name, location.rx, location.ry);
+                }
+                else {
+                    logger(`Completed: ${queueTypeToName(queueType)}: ${objectReady.name} but nowhere to place it`);
+                }
+            }
+        }
+        else if (queueData.status == QueueStatus.Active && queueData.items.length > 0 && decision != null) {
+            // Consider cancelling if something else is significantly higher priority than what is currently being produced.
+            const currentProduction = queueData.items[0].rules;
+            if (decision.unit != currentProduction) {
+                // Changing our mind.
+                let currentItemPriority = this.getPriorityForBuildingOption(currentProduction, game, playerData, threatCache);
+                let newItemPriority = decision.priority;
+                if (newItemPriority > currentItemPriority * 2) {
+                    logger(`Dequeueing queue ${queueTypeToName(queueData.type)} unit ${currentProduction.name} because ${decision.unit.name} has 2x higher priority.`);
+                    actionsApi.unqueueFromProduction(queueData.type, currentProduction.name, currentProduction.type, 1);
+                }
+            }
+            else {
+                // Not changing our mind, but maybe other queues are more important for now.
+                if (totalCostAcrossQueues > myCredits && decision.priority < totalWeightAcrossQueues * 0.25) {
+                    logger(`Pausing queue ${queueTypeToName(queueData.type)} because weight is low (${decision.priority}/${totalWeightAcrossQueues})`);
+                    actionsApi.pauseProduction(queueData.type);
+                }
+            }
+        }
+        else if (queueData.status == QueueStatus.OnHold) {
+            // Consider resuming queue if priority is high relative to other queues.
+            if (myCredits >= totalCostAcrossQueues) {
+                logger(`Resuming queue ${queueTypeToName(queueData.type)} because credits are high`);
+                actionsApi.resumeProduction(queueData.type);
+            }
+            else if (decision && decision.priority >= totalWeightAcrossQueues * 0.25) {
+                logger(`Resuming queue ${queueTypeToName(queueData.type)} because weight is high (${decision.priority}/${totalWeightAcrossQueues})`);
+                actionsApi.resumeProduction(queueData.type);
+            }
+        }
+    }
+    getPrioritiesForBuildingOptions(game, options, threatCache, playerData, unitTypeRequests, logger) {
+        let priorityQueue = [];
+        options.forEach((option) => {
+            const calculatedPriority = this.getPriorityForBuildingOption(option, game, playerData, threatCache);
+            // Get the higher of the dynamic and the mission priority for the unit.
+            const actualPriority = Math.max(calculatedPriority, unitTypeRequests.get(option.name) ?? calculatedPriority);
+            if (actualPriority > 0) {
+                priorityQueue.push({ unit: option, priority: actualPriority });
+            }
+        });
+        priorityQueue = priorityQueue.sort((a, b) => a.priority - b.priority);
+        return priorityQueue;
+    }
+    getPriorityForBuildingOption(option, game, playerStatus, threatCache) {
+        if (BUILDING_NAME_TO_RULES.has(option.name)) {
+            let logic = BUILDING_NAME_TO_RULES.get(option.name);
+            return logic.getPriority(game, playerStatus, option, threatCache);
+        }
+        else {
+            // Fallback priority when there are no rules.
+            return (DEFAULT_BUILDING_PRIORITY - game.getVisibleUnits(playerStatus.name, "self", (r) => r == option).length);
+        }
+    }
+    getBestLocationForStructure(game, playerData, objectReady) {
+        if (BUILDING_NAME_TO_RULES.has(objectReady.name)) {
+            let logic = BUILDING_NAME_TO_RULES.get(objectReady.name);
+            return logic.getPlacementLocation(game, playerData, objectReady);
+        }
+        else {
+            // fallback placement logic
+            return getDefaultPlacementLocation(game, playerData, playerData.startLocation, objectReady);
+        }
+    }
+    getGlobalDebugText(gameApi, productionApi) {
+        const productionState = QUEUES.reduce((prev, queueType) => {
+            if (productionApi.getQueueData(queueType).size === 0) {
+                return prev;
+            }
+            const paused = productionApi.getQueueData(queueType).status === QueueStatus.OnHold;
+            return (prev +
+                " [" +
+                queueTypeToName(queueType) +
+                (paused ? " PAUSED" : "") +
+                ": " +
+                productionApi
+                    .getQueueData(queueType)
+                    .items.map((item) => item.rules.name + (item.quantity > 1 ? "x" + item.quantity : "")) +
+                "]");
+        }, "");
+        const queueStates = this.queueStates
+            .filter((queueState) => queueState.items.length > 0)
+            .map((queueState) => {
+            const queueString = queueState.items
+                .map((item) => item.unit.name + "(" + Math.round(item.priority * 10) / 10 + ")")
+                .join(", ");
+            return `${queueTypeToName(queueState.queue)} Prios: ${queueString}\n`;
+        })
+            .join("");
+        return `Production: ${productionState}\n${queueStates}`;
+    }
+}
 //# sourceMappingURL=queueController.js.map

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

@@ -1,37 +1,37 @@
-import { GameMath } from "@chronodivide/game-api";
-import { BasicBuilding } from "./basicBuilding.js";
-import { getDefaultPlacementLocation } from "./buildingRules.js";
-import { Vector2 } from "three";
-export class ResourceCollectionBuilding extends BasicBuilding {
-    constructor(basePriority, maxNeeded, onlyBuildWhenFloatingCreditsAmount) {
-        super(basePriority, maxNeeded, onlyBuildWhenFloatingCreditsAmount);
-    }
-    getPlacementLocation(game, playerData, technoRules) {
-        // Prefer spawning close to ore.
-        let selectedLocation = playerData.startLocation;
-        var closeOre;
-        var closeOreDist;
-        let allTileResourceData = game.mapApi.getAllTilesResourceData();
-        for (let i = 0; i < allTileResourceData.length; ++i) {
-            let tileResourceData = allTileResourceData[i];
-            if (tileResourceData.spawnsOre) {
-                let dist = GameMath.sqrt((selectedLocation.x - tileResourceData.tile.rx) ** 2 +
-                    (selectedLocation.y - tileResourceData.tile.ry) ** 2);
-                if (closeOreDist == undefined || dist < closeOreDist) {
-                    closeOreDist = dist;
-                    closeOre = tileResourceData.tile;
-                }
-            }
-        }
-        if (closeOre) {
-            selectedLocation = new Vector2(closeOre.rx, closeOre.ry);
-        }
-        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules);
-    }
-    // Don't build/start selling these if we don't have any harvesters
-    getMaxCount(game, playerData, technoRules, threatCache) {
-        const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
-        return Math.max(1, harvesters * 2);
-    }
-}
+import { GameMath } from "@chronodivide/game-api";
+import { BasicBuilding } from "./basicBuilding.js";
+import { getDefaultPlacementLocation } from "./buildingRules.js";
+import { Vector2 } from "three";
+export class ResourceCollectionBuilding extends BasicBuilding {
+    constructor(basePriority, maxNeeded, onlyBuildWhenFloatingCreditsAmount) {
+        super(basePriority, maxNeeded, onlyBuildWhenFloatingCreditsAmount);
+    }
+    getPlacementLocation(game, playerData, technoRules) {
+        // Prefer spawning close to ore.
+        let selectedLocation = playerData.startLocation;
+        var closeOre;
+        var closeOreDist;
+        let allTileResourceData = game.mapApi.getAllTilesResourceData();
+        for (let i = 0; i < allTileResourceData.length; ++i) {
+            let tileResourceData = allTileResourceData[i];
+            if (tileResourceData.spawnsOre) {
+                let dist = GameMath.sqrt((selectedLocation.x - tileResourceData.tile.rx) ** 2 +
+                    (selectedLocation.y - tileResourceData.tile.ry) ** 2);
+                if (closeOreDist == undefined || dist < closeOreDist) {
+                    closeOreDist = dist;
+                    closeOre = tileResourceData.tile;
+                }
+            }
+        }
+        if (closeOre) {
+            selectedLocation = new Vector2(closeOre.rx, closeOre.ry);
+        }
+        return getDefaultPlacementLocation(game, playerData, selectedLocation, technoRules);
+    }
+    // Don't build/start selling these if we don't have any harvesters
+    getMaxCount(game, playerData, technoRules, threatCache) {
+        const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
+        return Math.max(1, harvesters * 2);
+    }
+}
 //# sourceMappingURL=resourceCollectionBuilding.js.map