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

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

@@ -1,127 +1,127 @@
-import { GameMath } from "@chronodivide/game-api";
-import { PriorityQueue } from "@datastructures-js/priority-queue";
-export const getUnseenStartingLocations = (gameApi, 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;
-};
-export class PrioritisedScoutTarget {
-    constructor(priority, target, permanent = false) {
-        this.permanent = permanent;
-        if (target.hasOwnProperty("x") && target.hasOwnProperty("y")) {
-            this._targetPoint = target;
-        }
-        else if (target.hasOwnProperty("sectorStartPoint")) {
-            this._targetSector = target;
-        }
-        else {
-            throw new TypeError(`invalid object passed as target: ${target}`);
-        }
-        this._priority = priority;
-    }
-    get priority() {
-        return this._priority;
-    }
-    asVector2() {
-        return this._targetPoint ?? this._targetSector?.sectorStartPoint ?? null;
-    }
-    get targetSector() {
-        return this._targetSector;
-    }
-    get isPermanent() {
-        return this.permanent;
-    }
-}
-const ENEMY_SPAWN_POINT_PRIORITY = 100;
-// Amount of sectors around the starting sector to try to scout.
-const NEARBY_SECTOR_STARTING_RADIUS = 2;
-const NEARBY_SECTOR_BASE_PRIORITY = 1000;
-// Amount of ticks per 'radius' to expand for scouting.
-const SCOUTING_RADIUS_EXPANSION_TICKS = 9000; // 10 minutes
-export class ScoutingManager {
-    constructor(logger) {
-        this.logger = logger;
-        this.queuedRadius = NEARBY_SECTOR_STARTING_RADIUS;
-        // Order by descending priority.
-        this.scoutingQueue = new PriorityQueue((a, b) => b.priority - a.priority);
-    }
-    addRadiusToScout(gameApi, centerPoint, sectorCache, radius, startingPriority) {
-        const { x: startX, y: startY } = centerPoint;
-        const { width: sectorsX, height: sectorsY } = sectorCache.getSectorBounds();
-        const startingSector = sectorCache.getSectorCoordinatesForWorldPosition(startX, startY);
-        if (!startingSector) {
-            return;
-        }
-        for (let x = Math.max(0, startingSector.sectorX - radius); x < Math.min(sectorsX, startingSector.sectorX + radius); ++x) {
-            for (let y = Math.max(0, startingSector.sectorY - radius); y < Math.min(sectorsY, startingSector.sectorY + radius); ++y) {
-                if (x === startingSector?.sectorX && y === startingSector?.sectorY) {
-                    continue;
-                }
-                // Make it scout closer sectors first.
-                const distanceFactor = GameMath.pow(x - startingSector.sectorX, 2) + GameMath.pow(y - startingSector.sectorY, 2);
-                const sector = sectorCache.getSector(x, y);
-                if (sector) {
-                    const maybeTarget = new PrioritisedScoutTarget(startingPriority - distanceFactor, sector);
-                    const maybePoint = maybeTarget.asVector2();
-                    if (maybePoint && gameApi.mapApi.getTile(maybePoint.x, maybePoint.y)) {
-                        this.scoutingQueue.enqueue(maybeTarget);
-                    }
-                }
-            }
-        }
-    }
-    onGameStart(gameApi, playerData, sectorCache) {
-        // Queue hostile starting locations with high priority and as permanent scouting candidates.
-        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;
-        })
-            .map((tile) => new PrioritisedScoutTarget(ENEMY_SPAWN_POINT_PRIORITY, tile, true))
-            .forEach((target) => {
-            this.logger(`Adding ${target.asVector2()?.x},${target.asVector2()?.y} to initial scouting queue`);
-            this.scoutingQueue.enqueue(target);
-        });
-        // Queue sectors near the spawn point.
-        this.addRadiusToScout(gameApi, playerData.startLocation, sectorCache, NEARBY_SECTOR_STARTING_RADIUS, NEARBY_SECTOR_BASE_PRIORITY);
-    }
-    onAiUpdate(gameApi, playerData, sectorCache) {
-        const currentHead = this.scoutingQueue.front();
-        if (!currentHead) {
-            return;
-        }
-        const head = currentHead.asVector2();
-        if (!head) {
-            this.scoutingQueue.dequeue();
-            return;
-        }
-        const { x, y } = head;
-        const tile = gameApi.mapApi.getTile(x, y);
-        if (tile && gameApi.mapApi.isVisibleTile(tile, playerData.name)) {
-            this.logger(`head point is visible, dequeueing`);
-            this.scoutingQueue.dequeue();
-        }
-        const requiredRadius = Math.floor(gameApi.getCurrentTick() / SCOUTING_RADIUS_EXPANSION_TICKS);
-        if (requiredRadius > this.queuedRadius) {
-            this.logger(`expanding scouting radius from ${this.queuedRadius} to ${requiredRadius}`);
-            this.addRadiusToScout(gameApi, playerData.startLocation, sectorCache, requiredRadius, NEARBY_SECTOR_BASE_PRIORITY);
-            this.queuedRadius = requiredRadius;
-        }
-    }
-    getNewScoutTarget() {
-        return this.scoutingQueue.dequeue();
-    }
-    hasScoutTargets() {
-        return !this.scoutingQueue.isEmpty();
-    }
-}
+import { GameMath } from "@chronodivide/game-api";
+import { PriorityQueue } from "@datastructures-js/priority-queue";
+export const getUnseenStartingLocations = (gameApi, 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;
+};
+export class PrioritisedScoutTarget {
+    constructor(priority, target, permanent = false) {
+        this.permanent = permanent;
+        if (target.hasOwnProperty("x") && target.hasOwnProperty("y")) {
+            this._targetPoint = target;
+        }
+        else if (target.hasOwnProperty("sectorStartPoint")) {
+            this._targetSector = target;
+        }
+        else {
+            throw new TypeError(`invalid object passed as target: ${target}`);
+        }
+        this._priority = priority;
+    }
+    get priority() {
+        return this._priority;
+    }
+    asVector2() {
+        return this._targetPoint ?? this._targetSector?.sectorStartPoint ?? null;
+    }
+    get targetSector() {
+        return this._targetSector;
+    }
+    get isPermanent() {
+        return this.permanent;
+    }
+}
+const ENEMY_SPAWN_POINT_PRIORITY = 100;
+// Amount of sectors around the starting sector to try to scout.
+const NEARBY_SECTOR_STARTING_RADIUS = 2;
+const NEARBY_SECTOR_BASE_PRIORITY = 1000;
+// Amount of ticks per 'radius' to expand for scouting.
+const SCOUTING_RADIUS_EXPANSION_TICKS = 9000; // 10 minutes
+export class ScoutingManager {
+    constructor(logger) {
+        this.logger = logger;
+        this.queuedRadius = NEARBY_SECTOR_STARTING_RADIUS;
+        // Order by descending priority.
+        this.scoutingQueue = new PriorityQueue((a, b) => b.priority - a.priority);
+    }
+    addRadiusToScout(gameApi, centerPoint, sectorCache, radius, startingPriority) {
+        const { x: startX, y: startY } = centerPoint;
+        const { width: sectorsX, height: sectorsY } = sectorCache.getSectorBounds();
+        const startingSector = sectorCache.getSectorCoordinatesForWorldPosition(startX, startY);
+        if (!startingSector) {
+            return;
+        }
+        for (let x = Math.max(0, startingSector.sectorX - radius); x < Math.min(sectorsX, startingSector.sectorX + radius); ++x) {
+            for (let y = Math.max(0, startingSector.sectorY - radius); y < Math.min(sectorsY, startingSector.sectorY + radius); ++y) {
+                if (x === startingSector?.sectorX && y === startingSector?.sectorY) {
+                    continue;
+                }
+                // Make it scout closer sectors first.
+                const distanceFactor = GameMath.pow(x - startingSector.sectorX, 2) + GameMath.pow(y - startingSector.sectorY, 2);
+                const sector = sectorCache.getSector(x, y);
+                if (sector) {
+                    const maybeTarget = new PrioritisedScoutTarget(startingPriority - distanceFactor, sector);
+                    const maybePoint = maybeTarget.asVector2();
+                    if (maybePoint && gameApi.mapApi.getTile(maybePoint.x, maybePoint.y)) {
+                        this.scoutingQueue.enqueue(maybeTarget);
+                    }
+                }
+            }
+        }
+    }
+    onGameStart(gameApi, playerData, sectorCache) {
+        // Queue hostile starting locations with high priority and as permanent scouting candidates.
+        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;
+        })
+            .map((tile) => new PrioritisedScoutTarget(ENEMY_SPAWN_POINT_PRIORITY, tile, true))
+            .forEach((target) => {
+            this.logger(`Adding ${target.asVector2()?.x},${target.asVector2()?.y} to initial scouting queue`);
+            this.scoutingQueue.enqueue(target);
+        });
+        // Queue sectors near the spawn point.
+        this.addRadiusToScout(gameApi, playerData.startLocation, sectorCache, NEARBY_SECTOR_STARTING_RADIUS, NEARBY_SECTOR_BASE_PRIORITY);
+    }
+    onAiUpdate(gameApi, playerData, sectorCache) {
+        const currentHead = this.scoutingQueue.front();
+        if (!currentHead) {
+            return;
+        }
+        const head = currentHead.asVector2();
+        if (!head) {
+            this.scoutingQueue.dequeue();
+            return;
+        }
+        const { x, y } = head;
+        const tile = gameApi.mapApi.getTile(x, y);
+        if (tile && gameApi.mapApi.isVisibleTile(tile, playerData.name)) {
+            this.logger(`head point is visible, dequeueing`);
+            this.scoutingQueue.dequeue();
+        }
+        const requiredRadius = Math.floor(gameApi.getCurrentTick() / SCOUTING_RADIUS_EXPANSION_TICKS);
+        if (requiredRadius > this.queuedRadius) {
+            this.logger(`expanding scouting radius from ${this.queuedRadius} to ${requiredRadius}`);
+            this.addRadiusToScout(gameApi, playerData.startLocation, sectorCache, requiredRadius, NEARBY_SECTOR_BASE_PRIORITY);
+            this.queuedRadius = requiredRadius;
+        }
+    }
+    getNewScoutTarget() {
+        return this.scoutingQueue.dequeue();
+    }
+    hasScoutTargets() {
+        return !this.scoutingQueue.isEmpty();
+    }
+}
 //# sourceMappingURL=scout.js.map

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

@@ -1,96 +1,96 @@
-export var Countries;
-(function (Countries) {
-    Countries["USA"] = "Americans";
-    Countries["KOREA"] = "Alliance";
-    Countries["FRANCE"] = "French";
-    Countries["GERMANY"] = "Germans";
-    Countries["GREAT_BRITAIN"] = "British";
-    Countries["LIBYA"] = "Africans";
-    Countries["IRAQ"] = "Arabs";
-    Countries["CUBA"] = "Confederation";
-    Countries["RUSSIA"] = "Russians";
-})(Countries || (Countries = {}));
-export const isOwnedByNeutral = (unitData) => unitData?.owner === "@@NEUTRAL@@";
-// Return if the given unit would have .isSelectableCombatant = true.
-// Usable on GameObjectData (which is faster to get than TechnoRules)
-export const isSelectableCombatant = (rules) => !!rules?.rules?.isSelectableCombatant;
-// Thanks use-strict!
-export function formatTimeDuration(timeSeconds, skipZeroHours = false) {
-    let h = Math.floor(timeSeconds / 3600);
-    timeSeconds -= h * 3600;
-    let m = Math.floor(timeSeconds / 60);
-    timeSeconds -= m * 60;
-    let s = Math.floor(timeSeconds);
-    return [...(h || !skipZeroHours ? [h] : []), pad(m, "00"), pad(s, "00")].join(":");
-}
-export function pad(n, format = "0000") {
-    let str = "" + n;
-    return format.substring(0, format.length - str.length) + str;
-}
-// So we don't need lodash
-export function minBy(array, predicate) {
-    if (array.length === 0) {
-        return null;
-    }
-    let minIdx = 0;
-    let minVal = predicate(array[0]);
-    for (let i = 1; i < array.length; ++i) {
-        const newVal = predicate(array[i]);
-        if (minVal === null || (newVal !== null && newVal < minVal)) {
-            minIdx = i;
-            minVal = newVal;
-        }
-    }
-    return array[minIdx];
-}
-export function maxBy(array, predicate) {
-    if (array.length === 0) {
-        return null;
-    }
-    let maxIdx = 0;
-    let maxVal = predicate(array[0]);
-    for (let i = 1; i < array.length; ++i) {
-        const newVal = predicate(array[i]);
-        if (maxVal === null || (newVal !== null && newVal > maxVal)) {
-            maxIdx = i;
-            maxVal = newVal;
-        }
-    }
-    return array[maxIdx];
-}
-export function uniqBy(array, predicate) {
-    return Object.values(array.reduce((prev, newVal) => {
-        const val = predicate(newVal);
-        if (!prev[val]) {
-            prev[val] = newVal;
-        }
-        return prev;
-    }, {}));
-}
-export function countBy(array, predicate) {
-    return array.reduce((prev, newVal) => {
-        const val = predicate(newVal);
-        if (val === undefined) {
-            return prev;
-        }
-        if (!prev[val]) {
-            prev[val] = 0;
-        }
-        prev[val] = prev[val] + 1;
-        return prev;
-    }, {});
-}
-export function groupBy(array, predicate) {
-    return array.reduce((prev, newVal) => {
-        const val = predicate(newVal);
-        if (val === undefined) {
-            return prev;
-        }
-        if (!prev.hasOwnProperty(val)) {
-            prev[val] = [];
-        }
-        prev[val].push(newVal);
-        return prev;
-    }, {});
-}
+export var Countries;
+(function (Countries) {
+    Countries["USA"] = "Americans";
+    Countries["KOREA"] = "Alliance";
+    Countries["FRANCE"] = "French";
+    Countries["GERMANY"] = "Germans";
+    Countries["GREAT_BRITAIN"] = "British";
+    Countries["LIBYA"] = "Africans";
+    Countries["IRAQ"] = "Arabs";
+    Countries["CUBA"] = "Confederation";
+    Countries["RUSSIA"] = "Russians";
+})(Countries || (Countries = {}));
+export const isOwnedByNeutral = (unitData) => unitData?.owner === "@@NEUTRAL@@";
+// Return if the given unit would have .isSelectableCombatant = true.
+// Usable on GameObjectData (which is faster to get than TechnoRules)
+export const isSelectableCombatant = (rules) => !!rules?.rules?.isSelectableCombatant;
+// Thanks use-strict!
+export function formatTimeDuration(timeSeconds, skipZeroHours = false) {
+    let h = Math.floor(timeSeconds / 3600);
+    timeSeconds -= h * 3600;
+    let m = Math.floor(timeSeconds / 60);
+    timeSeconds -= m * 60;
+    let s = Math.floor(timeSeconds);
+    return [...(h || !skipZeroHours ? [h] : []), pad(m, "00"), pad(s, "00")].join(":");
+}
+export function pad(n, format = "0000") {
+    let str = "" + n;
+    return format.substring(0, format.length - str.length) + str;
+}
+// So we don't need lodash
+export function minBy(array, predicate) {
+    if (array.length === 0) {
+        return null;
+    }
+    let minIdx = 0;
+    let minVal = predicate(array[0]);
+    for (let i = 1; i < array.length; ++i) {
+        const newVal = predicate(array[i]);
+        if (minVal === null || (newVal !== null && newVal < minVal)) {
+            minIdx = i;
+            minVal = newVal;
+        }
+    }
+    return array[minIdx];
+}
+export function maxBy(array, predicate) {
+    if (array.length === 0) {
+        return null;
+    }
+    let maxIdx = 0;
+    let maxVal = predicate(array[0]);
+    for (let i = 1; i < array.length; ++i) {
+        const newVal = predicate(array[i]);
+        if (maxVal === null || (newVal !== null && newVal > maxVal)) {
+            maxIdx = i;
+            maxVal = newVal;
+        }
+    }
+    return array[maxIdx];
+}
+export function uniqBy(array, predicate) {
+    return Object.values(array.reduce((prev, newVal) => {
+        const val = predicate(newVal);
+        if (!prev[val]) {
+            prev[val] = newVal;
+        }
+        return prev;
+    }, {}));
+}
+export function countBy(array, predicate) {
+    return array.reduce((prev, newVal) => {
+        const val = predicate(newVal);
+        if (val === undefined) {
+            return prev;
+        }
+        if (!prev[val]) {
+            prev[val] = 0;
+        }
+        prev[val] = prev[val] + 1;
+        return prev;
+    }, {});
+}
+export function groupBy(array, predicate) {
+    return array.reduce((prev, newVal) => {
+        const val = predicate(newVal);
+        if (val === undefined) {
+            return prev;
+        }
+        if (!prev.hasOwnProperty(val)) {
+            prev[val] = [];
+        }
+        prev[val].push(newVal);
+        return prev;
+    }, {});
+}
 //# sourceMappingURL=utils.js.map

package/dist/bot/logic/composition/alliedCompositions.js

@@ -1,13 +1,13 @@
-export const getAlliedCompositions = (gameApi, playerData, matchAwareness) => {
-    const hasWarFactory = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "GAWEAP").length > 0;
-    const hasAirforce = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "GAAIRC" || r.name === "AMRADR").length > 0;
-    const hasBattleLab = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "GATECH").length > 0;
-    const includeInfantry = !hasAirforce && !hasBattleLab;
-    return {
-        ...(includeInfantry && { E1: 5 }),
-        ...(hasWarFactory && { MTNK: 3, FV: 2 }),
-        ...(hasAirforce && { JUMPJET: 6 }),
-        ...(hasBattleLab && { SREF: 2, MGTK: 3 }),
-    };
-};
+export const getAlliedCompositions = (gameApi, playerData, matchAwareness) => {
+    const hasWarFactory = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "GAWEAP").length > 0;
+    const hasAirforce = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "GAAIRC" || r.name === "AMRADR").length > 0;
+    const hasBattleLab = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "GATECH").length > 0;
+    const includeInfantry = !hasAirforce && !hasBattleLab;
+    return {
+        ...(includeInfantry && { E1: 5 }),
+        ...(hasWarFactory && { MTNK: 3, FV: 2 }),
+        ...(hasAirforce && { JUMPJET: 6 }),
+        ...(hasBattleLab && { SREF: 2, MGTK: 3 }),
+    };
+};
 //# sourceMappingURL=alliedCompositions.js.map

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

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=common.js.map

package/dist/bot/logic/composition/sovietCompositions.js

@@ -1,13 +1,13 @@
-export const getSovietComposition = (gameApi, playerData, matchAwareness) => {
-    const hasWarFactory = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "NAWEAP").length > 0;
-    const hasRadar = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "NARADR").length > 0;
-    const hasBattleLab = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "NATECH").length > 0;
-    const includeInfantry = !hasBattleLab;
-    return {
-        ...(includeInfantry && { E2: 10 }),
-        ...(hasWarFactory && { HTNK: 3, HTK: 2 }),
-        ...(hasRadar && { V3: 1 }),
-        ...(hasBattleLab && { APOC: 2 }),
-    };
-};
+export const getSovietComposition = (gameApi, playerData, matchAwareness) => {
+    const hasWarFactory = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "NAWEAP").length > 0;
+    const hasRadar = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "NARADR").length > 0;
+    const hasBattleLab = gameApi.getVisibleUnits(playerData.name, "self", (r) => r.name === "NATECH").length > 0;
+    const includeInfantry = !hasBattleLab;
+    return {
+        ...(includeInfantry && { E2: 10 }),
+        ...(hasWarFactory && { HTNK: 3, HTK: 2 }),
+        ...(hasRadar && { V3: 1 }),
+        ...(hasBattleLab && { APOC: 2 }),
+    };
+};
 //# sourceMappingURL=sovietCompositions.js.map

package/dist/bot/logic/map/map.js

@@ -1,45 +1,45 @@
-import { GameMath, Vector2 } from "@chronodivide/game-api";
-export function determineMapBounds(mapApi) {
-    return mapApi.getRealMapSize();
-}
-export function calculateAreaVisibility(mapApi, playerData, startPoint, endPoint) {
-    let validTiles = 0, visibleTiles = 0;
-    for (let xx = startPoint.x; xx < endPoint.x; ++xx) {
-        for (let yy = startPoint.y; yy < endPoint.y; ++yy) {
-            let tile = mapApi.getTile(xx, yy);
-            if (tile) {
-                ++validTiles;
-                if (mapApi.isVisibleTile(tile, playerData.name)) {
-                    ++visibleTiles;
-                }
-            }
-        }
-    }
-    let result = { visibleTiles, validTiles };
-    return result;
-}
-export function getPointTowardsOtherPoint(gameApi, startLocation, endLocation, minRadius, maxRadius, randomAngle) {
-    // TODO: Use proper vector maths here.
-    let radius = minRadius + Math.round(gameApi.generateRandom() * (maxRadius - minRadius));
-    let directionToEndLocation = GameMath.atan2(endLocation.y - startLocation.y, endLocation.x - startLocation.x);
-    let randomisedDirection = directionToEndLocation -
-        (randomAngle * (Math.PI / 12) + 2 * randomAngle * gameApi.generateRandom() * (Math.PI / 12));
-    let candidatePointX = Math.round(startLocation.x + GameMath.cos(randomisedDirection) * radius);
-    let candidatePointY = Math.round(startLocation.y + GameMath.sin(randomisedDirection) * radius);
-    return new Vector2(candidatePointX, candidatePointY);
-}
-export function getDistanceBetweenPoints(startLocation, endLocation) {
-    // TODO: Remove this now we have Vector2s.
-    return startLocation.distanceTo(endLocation);
-}
-export function getDistanceBetweenTileAndPoint(tile, vector) {
-    // TODO: Remove this now we have Vector2s.
-    return new Vector2(tile.rx, tile.ry).distanceTo(vector);
-}
-export function getDistanceBetweenUnits(unit1, unit2) {
-    return new Vector2(unit1.tile.rx, unit1.tile.ry).distanceTo(new Vector2(unit2.tile.rx, unit2.tile.ry));
-}
-export function getDistanceBetween(unit, point) {
-    return getDistanceBetweenPoints(new Vector2(unit.tile.rx, unit.tile.ry), point);
-}
+import { GameMath, Vector2 } from "@chronodivide/game-api";
+export function determineMapBounds(mapApi) {
+    return mapApi.getRealMapSize();
+}
+export function calculateAreaVisibility(mapApi, playerData, startPoint, endPoint) {
+    let validTiles = 0, visibleTiles = 0;
+    for (let xx = startPoint.x; xx < endPoint.x; ++xx) {
+        for (let yy = startPoint.y; yy < endPoint.y; ++yy) {
+            let tile = mapApi.getTile(xx, yy);
+            if (tile) {
+                ++validTiles;
+                if (mapApi.isVisibleTile(tile, playerData.name)) {
+                    ++visibleTiles;
+                }
+            }
+        }
+    }
+    let result = { visibleTiles, validTiles };
+    return result;
+}
+export function getPointTowardsOtherPoint(gameApi, startLocation, endLocation, minRadius, maxRadius, randomAngle) {
+    // TODO: Use proper vector maths here.
+    let radius = minRadius + Math.round(gameApi.generateRandom() * (maxRadius - minRadius));
+    let directionToEndLocation = GameMath.atan2(endLocation.y - startLocation.y, endLocation.x - startLocation.x);
+    let randomisedDirection = directionToEndLocation -
+        (randomAngle * (Math.PI / 12) + 2 * randomAngle * gameApi.generateRandom() * (Math.PI / 12));
+    let candidatePointX = Math.round(startLocation.x + GameMath.cos(randomisedDirection) * radius);
+    let candidatePointY = Math.round(startLocation.y + GameMath.sin(randomisedDirection) * radius);
+    return new Vector2(candidatePointX, candidatePointY);
+}
+export function getDistanceBetweenPoints(startLocation, endLocation) {
+    // TODO: Remove this now we have Vector2s.
+    return startLocation.distanceTo(endLocation);
+}
+export function getDistanceBetweenTileAndPoint(tile, vector) {
+    // TODO: Remove this now we have Vector2s.
+    return new Vector2(tile.rx, tile.ry).distanceTo(vector);
+}
+export function getDistanceBetweenUnits(unit1, unit2) {
+    return new Vector2(unit1.tile.rx, unit1.tile.ry).distanceTo(new Vector2(unit2.tile.rx, unit2.tile.ry));
+}
+export function getDistanceBetween(unit, point) {
+    return getDistanceBetweenPoints(new Vector2(unit.tile.rx, unit.tile.ry), point);
+}
 //# sourceMappingURL=map.js.map