@supalosa/chronodivide-bot 0.1.1 → 0.2.0

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

@@ -1,120 +1,125 @@
-import { BuildingPlacementData, GameApi, PlayerData, Point2D, TechnoRules } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
-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";
-
-export interface AiBuildingRules {
-    getPriority(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | undefined
-    ): number;
-
-    getPlacementLocation(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules
-    ): { rx: number; ry: number } | undefined;
-
-    getMaxCount(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | undefined
-    ): number | null;
-}
-
-export function numBuildingsOwnedOfType(game: GameApi, playerData: PlayerData, technoRules: TechnoRules): number {
-    return game.getVisibleUnits(playerData.name, "self", (r) => r == technoRules).length;
-}
-
-export function numBuildingsOwnedOfName(game: GameApi, playerData: PlayerData, name: string): number {
-    return game.getVisibleUnits(playerData.name, "self", (r) => r.name === name).length;
-}
-
-export function getDefaultPlacementLocation(
-    game: GameApi,
-    playerData: PlayerData,
-    startPoint: Point2D,
-    technoRules: TechnoRules,
-    space: number = 1
-): { rx: number; ry: number } | undefined {
-    // Random location, preferably near start location.
-    let startX = startPoint.x;
-    let startY = startPoint.y;
-    let size: BuildingPlacementData = game.getBuildingPlacementData(technoRules.name);
-    if (!size) {
-        return undefined;
-    }
-    let largestSize = Math.max(size.foundation.height, size.foundation.width);
-    for (let searchRadius = largestSize; searchRadius < 25 + largestSize; ++searchRadius) {
-        for (let xx = startX - searchRadius; xx < startX + searchRadius; ++xx) {
-            for (let yy = startY - searchRadius; yy < startY + searchRadius; ++yy) {
-                let tile = game.mapApi.getTile(xx, yy);
-                if (tile && game.canPlaceBuilding(playerData.name, technoRules.name, tile)) {
-                    return { rx: xx, ry: yy };
-                }
-            }
-        }
-    }
-    console.log("Can't find a place to put the " + technoRules.name);
-    return undefined;
-}
-
-// Priority 0 = don't build.
-export type TechnoRulesWithPriority = { unit: TechnoRules; priority: number };
-
-export const DEFAULT_BUILDING_PRIORITY = 1;
-
-export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
-    // Allied
-    ["GAPOWR", new PowerPlant()],
-    ["GAREFN", new ResourceCollectionBuilding(10, 3)], // Refinery
-    ["GAWEAP", new BasicBuilding(15, 1)], // War Factory
-    ["GAPILE", new BasicBuilding(12, 1)], // Barracks
-    ["CMIN", new Harvester(15, 4, 2)], // Chrono Miner
-    ["ENGINEER", new BasicBuilding(1, 1, 10000)], // Engineer
-    ["GADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
-    ["GAAIRC", new BasicBuilding(8, 1, 6000)], // Airforce Command
-
-    ["GAPILL", new AntiGroundStaticDefence(5, 1, 5)], // Pillbox
-    ["ATESLA", new AntiGroundStaticDefence(5, 1, 10)], // Prism Cannon
-    ["GAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
-
-    ["E1", new BasicGroundUnit(5, 3, 0.25, 0)], // GI
-    ["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
-    ["JUMPJET", new BasicAirUnit(10, 1, 1, 1)], // Rocketeer
-    ["SREF", new ArtilleryUnit(9, 1)], // Prism Tank
-    ["CLEG", new BasicGroundUnit(0, 0)], // Chrono Legionnaire (Disabled - we don't handle the warped out phase properly and it tends to bug both bots out)
-    ["SHAD", new BasicGroundUnit(0, 0)], // Nighthawk (Disabled)
-
-    // Soviet
-    ["NAPOWR", new PowerPlant()],
-    ["NAREFN", new ResourceCollectionBuilding(10, 3)], // Refinery
-    ["NAWEAP", new BasicBuilding(15, 1)], // War Factory
-    ["NAHAND", new BasicBuilding(12, 1)], // Barracks
-    ["HARV", new Harvester(15, 4, 2)], // War Miner
-    ["SENGINEER", new BasicBuilding(1, 1, 10000)], // Soviet Engineer
-    ["NADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
-    ["NARADR", new BasicBuilding(8, 1, 4000)], // Radar
-
-    ["NALASR", new AntiGroundStaticDefence(5, 1, 5)], // Sentry Gun
-    ["TESLA", new AntiGroundStaticDefence(5, 1, 10)], // Tesla Coil
-    ["NAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
-
-    ["E2", new BasicGroundUnit(5, 3, 0.25, 0)], // Conscript
-    ["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
-    ["ZEP", new BasicAirUnit(5, 1, 5, 1)], // Kirov
-    ["V3", new ArtilleryUnit(9, 1)], // V3 Rocket Launcher
-]);
+import { BuildingPlacementData, GameApi, PlayerData, Point2D, TechnoRules } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+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";
+
+export interface AiBuildingRules {
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null,
+    ): number;
+
+    getPlacementLocation(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+    ): { rx: number; ry: number } | undefined;
+
+    getMaxCount(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null,
+    ): number | null;
+}
+
+export function numBuildingsOwnedOfType(game: GameApi, playerData: PlayerData, technoRules: TechnoRules): number {
+    return game.getVisibleUnits(playerData.name, "self", (r) => r == technoRules).length;
+}
+
+export function numBuildingsOwnedOfName(game: GameApi, playerData: PlayerData, name: string): number {
+    return game.getVisibleUnits(playerData.name, "self", (r) => r.name === name).length;
+}
+
+export function getDefaultPlacementLocation(
+    game: GameApi,
+    playerData: PlayerData,
+    startPoint: Point2D,
+    technoRules: TechnoRules,
+    space: number = 1,
+): { rx: number; ry: number } | undefined {
+    // Random location, preferably near start location.
+    let startX = startPoint.x;
+    let startY = startPoint.y;
+    let size: BuildingPlacementData = game.getBuildingPlacementData(technoRules.name);
+    if (!size) {
+        return undefined;
+    }
+    let largestSize = Math.max(size.foundation.height, size.foundation.width);
+    for (let searchRadius = largestSize; searchRadius < 25 + largestSize; ++searchRadius) {
+        for (let xx = startX - searchRadius; xx < startX + searchRadius; ++xx) {
+            for (let yy = startY - searchRadius; yy < startY + searchRadius; ++yy) {
+                let tile = game.mapApi.getTile(xx, yy);
+                if (tile && game.canPlaceBuilding(playerData.name, technoRules.name, tile)) {
+                    return { rx: xx, ry: yy };
+                }
+            }
+        }
+    }
+    return undefined;
+}
+
+// Priority 0 = don't build.
+export type TechnoRulesWithPriority = { unit: TechnoRules; priority: number };
+
+export const DEFAULT_BUILDING_PRIORITY = 1;
+
+export const BUILDING_NAME_TO_RULES = new Map<string, AiBuildingRules>([
+    // Allied
+    ["GAPOWR", new PowerPlant()],
+    ["GAREFN", new ResourceCollectionBuilding(10, 3)], // Refinery
+    ["GAWEAP", new BasicBuilding(15, 1)], // War Factory
+    ["GAPILE", new BasicBuilding(12, 1)], // Barracks
+    ["CMIN", new Harvester(15, 4, 2)], // Chrono Miner
+    ["ENGINEER", new BasicBuilding(1, 1, 10000)], // Engineer
+    ["GADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
+    ["GAAIRC", new BasicBuilding(8, 1, 6000)], // Airforce Command
+
+    ["GATECH", new BasicBuilding(20, 1, 4000)], // Allied Battle Lab
+
+    ["GAPILL", new AntiGroundStaticDefence(5, 1, 5)], // Pillbox
+    ["ATESLA", new AntiGroundStaticDefence(5, 1, 10)], // Prism Cannon
+    ["GAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
+
+    ["E1", new BasicGroundUnit(2, 3, 0.25, 0)], // GI
+    ["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
+    ["JUMPJET", new BasicAirUnit(10, 1, 1, 1)], // Rocketeer
+    ["ORCA", new BasicAirUnit(7, 1, 2, 0)], // Rocketeer
+    ["SREF", new ArtilleryUnit(9, 1)], // Prism Tank
+    ["CLEG", new BasicGroundUnit(0, 0)], // Chrono Legionnaire (Disabled - we don't handle the warped out phase properly and it tends to bug both bots out)
+    ["SHAD", new BasicGroundUnit(0, 0)], // Nighthawk (Disabled)
+
+    // Soviet
+    ["NAPOWR", new PowerPlant()],
+    ["NAREFN", new ResourceCollectionBuilding(10, 3)], // Refinery
+    ["NAWEAP", new BasicBuilding(15, 1)], // War Factory
+    ["NAHAND", new BasicBuilding(12, 1)], // Barracks
+    ["HARV", new Harvester(15, 4, 2)], // War Miner
+    ["SENGINEER", new BasicBuilding(1, 1, 10000)], // Soviet Engineer
+    ["NADEPT", new BasicBuilding(1, 1, 10000)], // Repair Depot
+    ["NARADR", new BasicBuilding(8, 1, 4000)], // Radar
+    ["NANRCT", new PowerPlant()], // Nuclear Reactor
+
+    ["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
+    ["NAWALL", new AntiGroundStaticDefence(0, 0, 0)], // Walls
+
+    ["E2", new BasicGroundUnit(2, 3, 0.25, 0)], // Conscript
+    ["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
+    ["ZEP", new BasicAirUnit(5, 1, 5, 1)], // Kirov
+    ["V3", new ArtilleryUnit(9, 1)], // V3 Rocket Launcher
+]);

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

@@ -1,27 +1,27 @@
-import { GameApi, PlayerData, Point2D, TechnoRules, Tile } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
-import { BasicBuilding } from "./basicBuilding.js";
-import { BasicGroundUnit } from "./basicGroundUnit.js";
-
-const IDEAL_HARVESTERS_PER_REFINERY = 2;
-
-export class Harvester extends BasicGroundUnit {
-    constructor(basePriority: number, baseAmount: number, private minNeeded: number) {
-        super(basePriority, baseAmount, 0, 0);
-    }
-
-    // Priority goes up when we have fewer than this many refineries.
-    getPriority(
-        game: GameApi,
-        playerData: PlayerData,
-        technoRules: TechnoRules,
-        threatCache: GlobalThreat | undefined
-    ): number {
-        const refineries = game.getVisibleUnits(playerData.name, "self", (r) => r.refinery).length;
-        const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
-
-        const boost = harvesters < this.minNeeded ? 5 : 1;
-
-        return this.basePriority * (refineries / Math.max(harvesters / IDEAL_HARVESTERS_PER_REFINERY, 1)) * boost;
-    }
-}
+import { GameApi, PlayerData, Point2D, TechnoRules, Tile } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { BasicBuilding } from "./basicBuilding.js";
+import { BasicGroundUnit } from "./basicGroundUnit.js";
+
+const IDEAL_HARVESTERS_PER_REFINERY = 2;
+
+export class Harvester extends BasicGroundUnit {
+    constructor(basePriority: number, baseAmount: number, private minNeeded: number) {
+        super(basePriority, baseAmount, 0, 0);
+    }
+
+    // Priority goes up when we have fewer than this many refineries.
+    getPriority(
+        game: GameApi,
+        playerData: PlayerData,
+        technoRules: TechnoRules,
+        threatCache: GlobalThreat | null
+    ): number {
+        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;
+
+        return this.basePriority * (refineries / Math.max(harvesters / IDEAL_HARVESTERS_PER_REFINERY, 1)) * boost;
+    }
+}

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

@@ -25,7 +25,7 @@ export class PowerPlant implements AiBuildingRules {
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | undefined
+        threatCache: GlobalThreat | null
     ): number | null {
         return null;
     }

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

@@ -43,27 +43,18 @@ export const queueTypeToName = (queue: QueueType) => {
     }
 };
 
-// Repair buildings at this ratio of the maxHitpoints.
-const REPAIR_HITPOINTS_RATIO = 0.9;
-
-// Don't repair buildings more often than this.
-const REPAIR_COOLDOWN_TICKS = 15;
-
 const DEBUG_BUILD_QUEUES = true;
 
 export class QueueController {
-    constructor(
-        private buildingIdToLastHitpoints: Map<number, number> = new Map(),
-        private buildingIdLastRepairedAtTick: Map<number, number> = new Map()
-    ) {}
+    constructor() {}
 
     public onAiUpdate(
         game: GameApi,
         productionApi: ProductionApi,
         actionsApi: ActionsApi,
         playerData: PlayerData,
-        threatCache: GlobalThreat | undefined,
-        logger: (message: string) => void
+        threatCache: GlobalThreat | null,
+        logger: (message: string) => void,
     ) {
         const decisions = QUEUES.map((queueType) => {
             const options = productionApi.getAvailableObjects(queueType);
@@ -90,29 +81,17 @@ export class QueueController {
                 decision.decision,
                 totalWeightAcrossQueues,
                 totalCostAcrossQueues,
-                logger
+                logger,
             );
         });
 
         // Repair is simple - just repair everything that's damaged.
-        // Unfortunately there doesn't seem to be an API to determine if something is being repaired, so we have to remember it.
         game.getVisibleUnits(playerData.name, "self", (r) => r.repairable).forEach((unitId) => {
             const unit = game.getUnitData(unitId);
-            if (!unit || !unit.hitPoints || !unit.maxHitPoints) {
+            if (!unit || !unit.hitPoints || !unit.maxHitPoints || unit.hasWrenchRepair) {
                 return;
             }
-            const lastKnownHitpoints = this.buildingIdToLastHitpoints.get(unitId) || unit.hitPoints;
-            const buildingLastRepairedAt = this.buildingIdLastRepairedAtTick.get(unitId) || 0;
-            // Only repair if HP is going down and if we haven't recently repaired it
-            if (
-                unit.hitPoints <= lastKnownHitpoints &&
-                game.getCurrentTick() > buildingLastRepairedAt + REPAIR_COOLDOWN_TICKS &&
-                unit.hitPoints < unit.maxHitPoints * REPAIR_HITPOINTS_RATIO
-            ) {
-                actionsApi.toggleRepairWrench(unitId);
-                this.buildingIdLastRepairedAtTick.set(unitId, game.getCurrentTick());
-            }
-            this.buildingIdToLastHitpoints.set(unitId, unit.hitPoints);
+            actionsApi.toggleRepairWrench(unitId);
         });
     }
 
@@ -121,16 +100,16 @@ export class QueueController {
         productionApi: ProductionApi,
         actionsApi: ActionsApi,
         playerData: PlayerData,
-        threatCache: GlobalThreat | undefined,
+        threatCache: GlobalThreat | null,
         queueType: QueueType,
         decision: TechnoRulesWithPriority | undefined,
         totalWeightAcrossQueues: number,
         totalCostAcrossQueues: number,
-        logger: (message: string) => void
+        logger: (message: string) => void,
     ): void {
         const myCredits = playerData.credits;
 
-        let queueData = productionApi.getQueueData(queueType);
+        const queueData = productionApi.getQueueData(queueType);
         if (queueData.status == QueueStatus.Idle) {
             // Start building the decided item.
             if (decision !== undefined) {
@@ -145,7 +124,7 @@ export class QueueController {
                 let location: { rx: number; ry: number } | undefined = this.getBestLocationForStructure(
                     game,
                     playerData,
-                    objectReady
+                    objectReady,
                 );
                 if (location !== undefined) {
                     actionsApi.placeBuilding(objectReady.name, location.rx, location.ry);
@@ -163,7 +142,7 @@ export class QueueController {
                     logger(
                         `Dequeueing queue ${queueTypeToName(queueData.type)} unit ${current.name} because ${
                             decision.unit.name
-                        } has 2x higher priority.`
+                        } has 2x higher priority.`,
                     );
                     actionsApi.unqueueFromProduction(queueData.type, current.name, current.type, 1);
                 }
@@ -173,7 +152,7 @@ export class QueueController {
                     logger(
                         `Pausing queue ${queueTypeToName(queueData.type)} because weight is low (${
                             decision.priority
-                        }/${totalWeightAcrossQueues})`
+                        }/${totalWeightAcrossQueues})`,
                     );
                     actionsApi.pauseProduction(queueData.type);
                 }
@@ -187,7 +166,7 @@ export class QueueController {
                 logger(
                     `Resuming queue ${queueTypeToName(queueData.type)} because weight is high (${
                         decision.priority
-                    }/${totalWeightAcrossQueues})`
+                    }/${totalWeightAcrossQueues})`,
                 );
                 actionsApi.resumeProduction(queueData.type);
             }
@@ -197,9 +176,9 @@ export class QueueController {
     private getBestOptionForBuilding(
         game: GameApi,
         options: TechnoRules[],
-        threatCache: GlobalThreat | undefined,
+        threatCache: GlobalThreat | null,
         playerData: PlayerData,
-        logger: (message: string) => void
+        logger: (message: string) => void,
     ): TechnoRulesWithPriority | undefined {
         let priorityQueue: TechnoRulesWithPriority[] = [];
         options.forEach((option) => {
@@ -226,7 +205,7 @@ export class QueueController {
         option: TechnoRules,
         game: GameApi,
         playerStatus: PlayerData,
-        threatCache: GlobalThreat | undefined
+        threatCache: GlobalThreat | null,
     ) {
         if (BUILDING_NAME_TO_RULES.has(option.name)) {
             let logic = BUILDING_NAME_TO_RULES.get(option.name)!;
@@ -242,7 +221,7 @@ export class QueueController {
     private getBestLocationForStructure(
         game: GameApi,
         playerData: PlayerData,
-        objectReady: TechnoRules
+        objectReady: TechnoRules,
     ): { rx: number; ry: number } | undefined {
         if (BUILDING_NAME_TO_RULES.has(objectReady.name)) {
             let logic = BUILDING_NAME_TO_RULES.get(objectReady.name)!;

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

@@ -48,7 +48,7 @@ export class ResourceCollectionBuilding extends BasicBuilding {
         game: GameApi,
         playerData: PlayerData,
         technoRules: TechnoRules,
-        threatCache: GlobalThreat | undefined
+        threatCache: GlobalThreat | null
     ): number | null {
         const harvesters = game.getVisibleUnits(playerData.name, "self", (r) => r.harvester).length;
         return Math.max(1, harvesters * 2);

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

@@ -0,0 +1,12 @@
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+
+export const getUnseenStartingLocations = (gameApi: GameApi, playerData: PlayerData) => {
+    const unseenStartingLocations = gameApi.mapApi.getStartingLocations().filter((startingLocation) => {
+        if (startingLocation == playerData.startLocation) {
+            return false;
+        }
+        let tile = gameApi.mapApi.getTile(startingLocation.x, startingLocation.y);
+        return tile ? !gameApi.mapApi.isVisibleTile(tile, playerData.name) : false;
+    });
+    return unseenStartingLocations;
+};

package/src/bot/logic/map/map.ts

@@ -1,4 +1,4 @@
-import { GameApi, MapApi, PlayerData, Point2D } from "@chronodivide/game-api";
+import { GameApi, MapApi, PlayerData, Point2D, UnitData } from "@chronodivide/game-api";
 
 // Expensive one-time call to determine the size of the map.
 // The result is a point just outside the bounds of the map.
@@ -35,7 +35,7 @@ export function calculateAreaVisibility(
     mapApi: MapApi,
     playerData: PlayerData,
     startPoint: Point2D,
-    endPoint: Point2D,
+    endPoint: Point2D
 ): { visibleTiles: number; validTiles: number } {
     let validTiles: number = 0,
         visibleTiles: number = 0;
@@ -60,7 +60,7 @@ export function getPointTowardsOtherPoint(
     endLocation: Point2D,
     minRadius: number,
     maxRadius: number,
-    randomAngle: number,
+    randomAngle: number
 ): Point2D {
     let radius = minRadius + Math.round(gameApi.generateRandom() * (maxRadius - minRadius));
     let directionToSpawn = Math.atan2(endLocation.y - startLocation.y, endLocation.x - startLocation.x);
@@ -74,3 +74,11 @@ export function getPointTowardsOtherPoint(
 export function getDistanceBetweenPoints(startLocation: Point2D, endLocation: Point2D): number {
     return Math.sqrt((startLocation.x - endLocation.x) ** 2 + (startLocation.y - endLocation.y) ** 2);
 }
+
+export function getDistanceBetweenUnits(unit1: UnitData, unit2: UnitData): number {
+    return getDistanceBetweenPoints({ x: unit1.tile.rx, y: unit1.tile.ry }, { x: unit2.tile.rx, y: unit2.tile.ry });
+}
+
+export function getDistanceBetween(unit: UnitData, point: Point2D): number {
+    return getDistanceBetweenPoints({ x: unit.tile.rx, y: unit.tile.ry }, point);
+}