@supalosa/chronodivide-bot 0.4.0 → 0.5.2

package/src/bot/logic/building/antiAirStaticDefence.ts

@@ -0,0 +1,64 @@
+import { GameApi, PlayerData, TechnoRules, Vector2 } from "@chronodivide/game-api";
+import { getPointTowardsOtherPoint } from "../map/map.js";
+import { GlobalThreat } from "../threat/threat.js";
+import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
+
+export class AntiAirStaticDefence implements AiBuildingRules {
+    constructor(
+        private basePriority: number,
+        private baseAmount: number,
+        private airStrength: number,
+    ) {}
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+    ): { rx: number; ry: number } | undefined {
+        // Prefer front towards enemy.
+        let startLocation = playerData.startLocation;
+        let players = game.getPlayers();
+        let enemyFacingLocationCandidates: Vector2[] = [];
+        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: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null,
+    ): number {
+        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: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null,
+    ): number | null {
+        return null;
+    }
+}

package/src/bot/logic/building/antiGroundStaticDefence.ts

@@ -2,12 +2,13 @@ import { GameApi, PlayerData, TechnoRules, Vector2 } from "@chronodivide/game-ap
 import { getPointTowardsOtherPoint } from "../map/map.js";
 import { GlobalThreat } from "../threat/threat.js";
 import { AiBuildingRules, getDefaultPlacementLocation, numBuildingsOwnedOfType } from "./buildingRules.js";
+import { getStaticDefencePlacement } from "./common.js";
 
 export class AntiGroundStaticDefence implements AiBuildingRules {
     constructor(
         private basePriority: number,
         private baseAmount: number,
-        private strength: number,
+        private groundStrength: number,
     ) {}
 
     getPlacementLocation(
@@ -15,23 +16,7 @@ export class AntiGroundStaticDefence implements AiBuildingRules {
         playerData: PlayerData,
         technoRules: TechnoRules,
     ): { rx: number; ry: number } | undefined {
-        // Prefer front towards enemy.
-        let startLocation = playerData.startLocation;
-        let players = game.getPlayers();
-        let enemyFacingLocationCandidates: Vector2[] = [];
-        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);
+        return getStaticDefencePlacement(game, playerData, technoRules);
     }
 
     getPriority(
@@ -43,12 +28,14 @@ export class AntiGroundStaticDefence implements AiBuildingRules {
         // If the enemy's ground power is increasing we should try to keep up.
         if (threatCache) {
             let denominator =
-                threatCache.totalAvailableAntiGroundFirepower + threatCache.totalDefensivePower + this.strength;
+                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.strength / technoRules.cost) * 1000;
+        const strengthPerCost = (this.groundStrength / technoRules.cost) * 1000;
         const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
         return this.basePriority * (1.0 - numOwned / this.baseAmount) * strengthPerCost;
     }

package/src/bot/logic/building/artilleryUnit.ts

@@ -24,34 +24,8 @@ export class ArtilleryUnit implements AiBuildingRules {
         technoRules: TechnoRules,
         threatCache: GlobalThreat | null,
     ): number {
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        let priority = this.basePriority;
-        // If the enemy's defensive power is increasing we will start to build these.
-        if (threatCache && threatCache.totalDefensivePower > threatCache.totalAvailableAntiGroundFirepower) {
-            priority +=
-                this.artilleryPower *
-                (threatCache.totalAvailableAntiGroundFirepower / Math.max(1, threatCache.totalDefensivePower));
-        }
-        if (threatCache && this.antiGroundPower > 0) {
-            // If the enemy's power is increasing we should try to keep up.
-            if (threatCache.totalOffensiveLandThreat > threatCache.totalAvailableAntiGroundFirepower) {
-                priority +=
-                    this.antiGroundPower *
-                    this.basePriority *
-                    (threatCache.totalOffensiveLandThreat / Math.max(1, threatCache.totalAvailableAntiGroundFirepower));
-            } else {
-                // But also, if our power dwarfs the enemy, keep pressing the advantage.
-                priority +=
-                    (this.antiGroundPower *
-                        this.basePriority *
-                        GameMath.sqrt(
-                            threatCache.totalAvailableAntiGroundFirepower /
-                                Math.max(1, threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat),
-                        )) /
-                    (numOwned + 1);
-            }
-        }
-        return priority * (1.0 - numOwned / this.baseAmount);
+        // Units aren't built automatically, but are instead requested by missions.
+        return 0;
     }
 
     getMaxCount(

package/src/bot/logic/building/basicAirUnit.ts

@@ -24,39 +24,8 @@ export class BasicAirUnit implements AiBuildingRules {
         technoRules: TechnoRules,
         threatCache: GlobalThreat | null,
     ): number {
-        // If the enemy's anti-air power is low we might build more.
-        if (threatCache) {
-            let priority = 0;
-            if (
-                this.antiGroundPower > 0 &&
-                threatCache.totalOffensiveLandThreat > threatCache.totalAvailableAntiGroundFirepower
-            ) {
-                priority +=
-                    this.basePriority *
-                    (threatCache.totalOffensiveLandThreat / Math.max(1, threatCache.totalAvailableAntiGroundFirepower));
-            }
-            if (
-                this.antiAirPower > 0 &&
-                threatCache.totalOffensiveAirThreat > threatCache.totalAvailableAntiAirFirepower
-            ) {
-                priority +=
-                    this.basePriority *
-                    (threatCache.totalOffensiveAirThreat / Math.max(1, threatCache.totalAvailableAntiAirFirepower));
-            }
-            // sqrt so we don't build too much of one unit type.
-            priority += Math.min(
-                1.0,
-                Math.max(
-                    1,
-                    GameMath.sqrt(
-                        threatCache.totalAvailableAirPower / Math.max(1, threatCache.totalOffensiveAntiAirThreat),
-                    ),
-                ),
-            );
-            return this.baseAmount * priority;
-        }
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        return this.basePriority * (1.0 - numOwned / this.baseAmount);
+        // Units aren't built automatically, but are instead requested by missions.
+        return 0;
     }
 
     getMaxCount(

package/src/bot/logic/building/basicBuilding.ts

@@ -6,13 +6,13 @@ export class BasicBuilding implements AiBuildingRules {
     constructor(
         protected basePriority: number,
         protected maxNeeded: number,
-        protected onlyBuildWhenFloatingCreditsAmount?: number
+        protected onlyBuildWhenFloatingCreditsAmount?: number,
     ) {}
 
     getPlacementLocation(
         game: GameApi,
         playerData: PlayerData,
-        technoRules: TechnoRules
+        technoRules: TechnoRules,
     ): { rx: number; ry: number } | undefined {
         return getDefaultPlacementLocation(game, playerData, playerData.startLocation, technoRules);
     }
@@ -21,7 +21,7 @@ export class BasicBuilding implements AiBuildingRules {
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
+        threatCache: GlobalThreat | null,
     ): number {
         const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
         const calcMaxCount = this.getMaxCount(game, playerData, technoRules, threatCache);
@@ -29,18 +29,20 @@ export class BasicBuilding implements AiBuildingRules {
             return -100;
         }
 
+        const priority = this.basePriority * (1.0 - numOwned / this.maxNeeded);
+
         if (this.onlyBuildWhenFloatingCreditsAmount && playerData.credits < this.onlyBuildWhenFloatingCreditsAmount) {
-            return -100;
+            return priority * (playerData.credits / this.onlyBuildWhenFloatingCreditsAmount);
         }
 
-        return this.basePriority * (1.0 - numOwned / this.maxNeeded);
+        return priority;
     }
 
     getMaxCount(
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | null
+        threatCache: GlobalThreat | null,
     ): number | null {
         return this.maxNeeded;
     }

package/src/bot/logic/building/basicGroundUnit.ts

@@ -24,52 +24,8 @@ export class BasicGroundUnit implements AiBuildingRules {
         technoRules: TechnoRules,
         threatCache: GlobalThreat | null,
     ): number {
-        const numOwned = numBuildingsOwnedOfType(game, playerData, technoRules);
-        if (threatCache) {
-            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) {
-                    priority +=
-                        this.antiGroundPower *
-                        this.basePriority *
-                        (threatCache.totalOffensiveLandThreat /
-                            Math.max(1, threatCache.totalAvailableAntiGroundFirepower));
-                } else {
-                    // But also, if our power dwarfs the enemy, keep pressing the advantage.
-                    priority +=
-                        (this.antiGroundPower *
-                            this.basePriority *
-                            GameMath.sqrt(
-                                threatCache.totalAvailableAntiGroundFirepower /
-                                    Math.max(
-                                        1,
-                                        threatCache.totalOffensiveLandThreat + threatCache.totalDefensiveThreat,
-                                    ),
-                            )) /
-                        (numOwned + 1);
-                }
-            }
-            if (this.antiAirPower > 0) {
-                if (threatCache.totalOffensiveAirThreat > threatCache.totalAvailableAntiAirFirepower) {
-                    priority +=
-                        this.antiAirPower *
-                        this.basePriority *
-                        (threatCache.totalOffensiveAirThreat / Math.max(1, threatCache.totalAvailableAntiAirFirepower));
-                } else {
-                    priority +=
-                        (this.antiAirPower *
-                            this.basePriority *
-                            GameMath.sqrt(
-                                threatCache.totalAvailableAntiAirFirepower /
-                                    Math.max(1, threatCache.totalOffensiveAirThreat + threatCache.totalDefensiveThreat),
-                            )) /
-                        (numOwned + 1);
-                }
-            }
-            return priority;
-        }
-        return this.basePriority * (1.0 - numOwned / this.baseAmount);
+        // Units aren't built automatically, but are instead requested by missions.
+        return 0;
     }
 
     getMaxCount(

package/src/bot/logic/building/buildingRules.ts

@@ -20,6 +20,7 @@ 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 interface AiBuildingRules {
     getPriority(
@@ -183,7 +184,7 @@ export function getDefaultPlacementLocation(
 // Priority 0 = don't build.
 export type TechnoRulesWithPriority = { unit: TechnoRules; priority: number };
 
-export const DEFAULT_BUILDING_PRIORITY = 1;
+export const DEFAULT_BUILDING_PRIORITY = 0;
 
 export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
     // Allied
@@ -192,7 +193,6 @@ export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
     ["GAWEAP", new BasicBuilding(15, 1)], // War Factory
     ["GAPILE", new BasicBuilding(12, 1)], // Barracks
     ["CMIN", new Harvester(15, 4, 2)], // Chrono Miner
-    ["ENGINEER", new BasicBuilding(10, 1, 1000)], // Engineer
     ["GADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
     ["GAAIRC", new BasicBuilding(10, 1, 500)], // Airforce Command
     ["AMRADR", new BasicBuilding(10, 1, 500)], // Airforce Command (USA)
@@ -200,11 +200,13 @@ export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
     ["GATECH", new BasicBuilding(20, 1, 4000)], // Allied Battle Lab
     ["GAYARD", new BasicBuilding(0, 0, 0)], // Naval Yard, disabled
 
-    ["GAPILL", new AntiGroundStaticDefence(5, 1, 5)], // Pillbox
-    ["ATESLA", new AntiGroundStaticDefence(5, 1, 10)], // Prism Cannon
+    ["GAPILL", new AntiGroundStaticDefence(2, 1, 5)], // Pillbox
+    ["ATESLA", new AntiGroundStaticDefence(2, 1, 10)], // Prism Cannon
+    ["NASAM", new AntiAirStaticDefence(2, 1, 5)], // Prism Cannon
     ["GAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
 
-    ["E1", new BasicGroundUnit(2, 3, 0.25, 0)], // GI
+    ["E1", new BasicGroundUnit(2, 2, 0.2, 0)], // GI
+    ["ENGINEER", new BasicGroundUnit(1, 0, 0)], // Engineer
     ["MTNK", new BasicGroundUnit(10, 3, 2, 0)], // Grizzly Tank
     ["MGTK", new BasicGroundUnit(10, 1, 2.5, 0)], // Mirage Tank
     ["FV", new BasicGroundUnit(5, 2, 0.5, 1)], // IFV
@@ -220,7 +222,6 @@ export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
     ["NAWEAP", new BasicBuilding(15, 1)], // War Factory
     ["NAHAND", new BasicBuilding(12, 1)], // Barracks
     ["HARV", new Harvester(15, 4, 2)], // War Miner
-    ["SENGINEER", new BasicBuilding(10, 1, 1000)], // Soviet Engineer
     ["NADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
     ["NARADR", new BasicBuilding(10, 1, 500)], // Radar
     ["NANRCT", new PowerPlant()], // Nuclear Reactor
@@ -228,11 +229,16 @@ export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
 
     ["NATECH", new BasicBuilding(20, 1, 4000)], // Soviet Battle Lab
 
-    ["NALASR", new AntiGroundStaticDefence(5, 1, 5)], // Sentry Gun
-    ["TESLA", new AntiGroundStaticDefence(5, 1, 10)], // Tesla Coil
+    ["NALASR", new AntiGroundStaticDefence(2, 1, 5)], // Sentry Gun
+    ["NAFLAK", new AntiAirStaticDefence(2, 1, 5)], // Flak Cannon
+    ["TESLA", new AntiGroundStaticDefence(2, 1, 10)], // Tesla Coil
     ["NAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
 
-    ["E2", new BasicGroundUnit(2, 3, 0.25, 0)], // Conscript
+    ["E2", new BasicGroundUnit(2, 2, 0.2, 0)], // Conscript
+    ["SENGINEER", new BasicGroundUnit(1, 0, 0)], // Soviet Engineer
+    ["FLAKT", new BasicGroundUnit(2, 2, 0.1, 0.3)], // Flak Trooper
+    ["YURI", new BasicGroundUnit(1, 1, 1, 0)], // Yuri
+    ["DOG", new BasicGroundUnit(1, 1, 0, 0)], // Soviet Attack Dog
     ["HTNK", new BasicGroundUnit(10, 3, 3, 0)], // Rhino Tank
     ["APOC", new BasicGroundUnit(6, 1, 5, 0)], // Apocalypse Tank
     ["HTK", new BasicGroundUnit(5, 2, 0.33, 1.5)], // Flak Track

package/src/bot/logic/building/common.ts

@@ -0,0 +1,23 @@
+import { GameApi, PlayerData, TechnoRules, Vector2 } from "@chronodivide/game-api";
+import { getPointTowardsOtherPoint } from "../map/map.js";
+import { getDefaultPlacementLocation } from "./buildingRules.js";
+
+export const getStaticDefencePlacement = (game: GameApi, playerData: PlayerData, technoRules: TechnoRules) => {
+    // Prefer front towards enemy.
+    let startLocation = playerData.startLocation;
+    let players = game.getPlayers();
+    let enemyFacingLocationCandidates: Vector2[] = [];
+    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);
+};

package/src/bot/logic/building/harvester.ts

@@ -3,6 +3,7 @@ import { GlobalThreat } from "../threat/threat.js";
 import { BasicGroundUnit } from "./basicGroundUnit.js";
 
 const IDEAL_HARVESTERS_PER_REFINERY = 2;
+const MAX_HARVESTERS_PER_REFINERY = 4;
 
 export class Harvester extends BasicGroundUnit {
     constructor(
@@ -23,7 +24,7 @@ export class Harvester extends BasicGroundUnit {
         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 : 1;
+        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;
     }

package/src/bot/logic/building/queueController.ts

@@ -14,6 +14,7 @@ import {
     DEFAULT_BUILDING_PRIORITY,
     getDefaultPlacementLocation,
 } from "./buildingRules.js";
+import { DebugLogger } from "../common/utils";
 
 export const QUEUES = [
     QueueType.Structures,
@@ -43,9 +44,16 @@ export const queueTypeToName = (queue: QueueType) => {
     }
 };
 
-const DEBUG_BUILD_QUEUES = true;
+type QueueState = {
+    queue: QueueType;
+    /** sorted in ascending order (last item is the topItem) */
+    items: TechnoRulesWithPriority[];
+    topItem: TechnoRulesWithPriority | undefined;
+};
 
 export class QueueController {
+    private queueStates: QueueState[] = [];
+
     constructor() {}
 
     public onAiUpdate(
@@ -54,23 +62,35 @@ export class QueueController {
         actionsApi: ActionsApi,
         playerData: PlayerData,
         threatCache: GlobalThreat | null,
+        unitTypeRequests: Map<string, number>,
         logger: (message: string) => void,
     ) {
-        const decisions = QUEUES.map((queueType) => {
+        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,
-                decision: this.getBestOptionForBuilding(game, options, threatCache, playerData, logger),
+                items,
+                // only if the top item has a  priority above zero
+                topItem: topItem && topItem.priority > 0 ? topItem : undefined,
             };
-        }).filter((decision) => decision.decision != null);
-        let totalWeightAcrossQueues = decisions
-            .map((decision) => decision.decision?.priority!)
+        });
+        const totalWeightAcrossQueues = this.queueStates
+            .map((decision) => decision.topItem?.priority!)
             .reduce((pV, cV) => pV + cV, 0);
-        let totalCostAcrossQueues = decisions
-            .map((decision) => decision.decision?.unit.cost!)
+        const totalCostAcrossQueues = this.queueStates
+            .map((decision) => decision.topItem?.unit.cost!)
             .reduce((pV, cV) => pV + cV, 0);
 
-        decisions.forEach((decision) => {
+        this.queueStates.forEach((decision) => {
             this.updateBuildQueue(
                 game,
                 productionApi,
@@ -78,7 +98,7 @@ export class QueueController {
                 playerData,
                 threatCache,
                 decision.queue,
-                decision.decision,
+                decision.topItem,
                 totalWeightAcrossQueues,
                 totalCostAcrossQueues,
                 logger,
@@ -86,15 +106,17 @@ export class QueueController {
         });
 
         // Repair is simple - just repair everything that's damaged.
-        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);
-            }
-        });
+        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);
+                }
+            });
+        }
     }
 
     private updateBuildQueue(
@@ -139,20 +161,24 @@ export class QueueController {
                 }
             }
         } else if (queueData.status == QueueStatus.Active && queueData.items.length > 0 && decision != null) {
-            // Consider cancelling if something else is significantly higher priority.
-            const current = queueData.items[0].rules;
-            const options = productionApi.getAvailableObjects(queueType);
-            if (decision.unit != current) {
+            // 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(current, game, playerData, threatCache);
+                let currentItemPriority = this.getPriorityForBuildingOption(
+                    currentProduction,
+                    game,
+                    playerData,
+                    threatCache,
+                );
                 let newItemPriority = decision.priority;
                 if (newItemPriority > currentItemPriority * 2) {
                     logger(
-                        `Dequeueing queue ${queueTypeToName(queueData.type)} unit ${current.name} because ${
+                        `Dequeueing queue ${queueTypeToName(queueData.type)} unit ${currentProduction.name} because ${
                             decision.unit.name
                         } has 2x higher priority.`,
                     );
-                    actionsApi.unqueueFromProduction(queueData.type, current.name, current.type, 1);
+                    actionsApi.unqueueFromProduction(queueData.type, currentProduction.name, currentProduction.type, 1);
                 }
             } else {
                 // Not changing our mind, but maybe other queues are more important for now.
@@ -181,32 +207,29 @@ export class QueueController {
         }
     }
 
-    private getBestOptionForBuilding(
+    private getPrioritiesForBuildingOptions(
         game: GameApi,
         options: TechnoRules[],
         threatCache: GlobalThreat | null,
         playerData: PlayerData,
-        logger: (message: string) => void,
-    ): TechnoRulesWithPriority | undefined {
+        unitTypeRequests: Map<string, number>,
+        logger: DebugLogger,
+    ): TechnoRulesWithPriority[] {
         let priorityQueue: TechnoRulesWithPriority[] = [];
         options.forEach((option) => {
-            let priority = this.getPriorityForBuildingOption(option, game, playerData, threatCache);
-            if (priority > 0) {
-                priorityQueue.push({ unit: option, priority: priority });
+            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) => {
-            return a.priority - b.priority;
-        });
-        if (priorityQueue.length > 0) {
-            if (DEBUG_BUILD_QUEUES && game.getCurrentTick() % 100 === 0) {
-                let queueString = priorityQueue.map((item) => item.unit.name + "(" + item.priority + ")").join(", ");
-                logger(`Build priority currently: ${queueString}`);
-            }
-        }
-
-        return priorityQueue.pop();
+        priorityQueue = priorityQueue.sort((a, b) => a.priority - b.priority);
+        return priorityQueue;
     }
 
     private getPriorityForBuildingOption(
@@ -239,4 +262,36 @@ export class QueueController {
             return getDefaultPlacementLocation(game, playerData, playerData.startLocation, objectReady);
         }
     }
+
+    public getGlobalDebugText(gameApi: GameApi, productionApi: 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}`;
+    }
 }