@supalosa/chronodivide-bot 0.5.3 → 0.6.4

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

@@ -1,112 +1,120 @@
-import { GameObjectData, TechnoRules, UnitData } from "@chronodivide/game-api";
-
-export type DebugLogger = (message: string, sayInGame?: boolean) => void;
-
-const SOVIET_COUNTRY_NAMES = ["Africans", "Arabs", "Confederation", "Russians"];
-
-export const isSoviet = (countryName: string) => SOVIET_COUNTRY_NAMES.includes(countryName);
-
-export const isOwnedByNeutral = (unitData: UnitData | undefined) => 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: GameObjectData | undefined) =>
-    !!(rules?.rules as any)?.isSelectableCombatant;
-
-// Thanks use-strict!
-export function formatTimeDuration(timeSeconds: number, 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: any, format = "0000") {
-    let str = "" + n;
-    return format.substring(0, format.length - str.length) + str;
-}
-
-// So we don't need lodash
-export function minBy<T>(array: T[], predicate: (arg: T) => number | null): T | null {
-    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<T>(array: T[], predicate: (arg: T) => number | null): T | null {
-    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<T>(array: T[], predicate: (arg: T) => string | number): T[] {
-    return Object.values(
-        array.reduce(
-            (prev, newVal) => {
-                const val = predicate(newVal);
-                if (!prev[val]) {
-                    prev[val] = newVal;
-                }
-                return prev;
-            },
-            {} as Record<string, T>,
-        ),
-    );
-}
-
-export function countBy<T>(array: T[], predicate: (arg: T) => string | undefined): { [key: string]: number } {
-    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;
-        },
-        {} as Record<string, number>,
-    );
-}
-
-export function groupBy<K extends string, V>(array: V[], predicate: (arg: V) => K): { [key in K]: V[] } {
-    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;
-        },
-        {} as Record<K, V[]>,
-    );
-}
+import { GameObjectData, TechnoRules, UnitData } from "@chronodivide/game-api";
+
+export enum Countries {
+    USA = "Americans",
+    KOREA = "Alliance",
+    FRANCE = "French",
+    GERMANY = "Germans",
+    GREAT_BRITAIN = "British",
+    LIBYA = "Africans",
+    IRAQ = "Arabs",
+    CUBA = "Confederation",
+    RUSSIA = "Russians",
+}
+
+export type DebugLogger = (message: string, sayInGame?: boolean) => void;
+
+export const isOwnedByNeutral = (unitData: UnitData | undefined) => 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: GameObjectData | undefined) =>
+    !!(rules?.rules as any)?.isSelectableCombatant;
+
+// Thanks use-strict!
+export function formatTimeDuration(timeSeconds: number, 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: any, format = "0000") {
+    let str = "" + n;
+    return format.substring(0, format.length - str.length) + str;
+}
+
+// So we don't need lodash
+export function minBy<T>(array: T[], predicate: (arg: T) => number | null): T | null {
+    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<T>(array: T[], predicate: (arg: T) => number | null): T | null {
+    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<T>(array: T[], predicate: (arg: T) => string | number): T[] {
+    return Object.values(
+        array.reduce(
+            (prev, newVal) => {
+                const val = predicate(newVal);
+                if (!prev[val]) {
+                    prev[val] = newVal;
+                }
+                return prev;
+            },
+            {} as Record<string, T>,
+        ),
+    );
+}
+
+export function countBy<T>(array: T[], predicate: (arg: T) => string | undefined): { [key: string]: number } {
+    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;
+        },
+        {} as Record<string, number>,
+    );
+}
+
+export function groupBy<K extends string, V>(array: V[], predicate: (arg: V) => K): { [key in K]: V[] } {
+    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;
+        },
+        {} as Record<K, V[]>,
+    );
+}

package/src/bot/logic/composition/alliedCompositions.ts

@@ -1,22 +1,22 @@
-import { GameApi, PlayerData } from "@chronodivide/game-api";
-import { MatchAwareness } from "../awareness";
-import { UnitComposition } from "./common";
-
-export const getAlliedCompositions = (
-    gameApi: GameApi,
-    playerData: PlayerData,
-    matchAwareness: MatchAwareness,
-): UnitComposition => {
-    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 }),
-    };
-};
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { MatchAwareness } from "../awareness";
+import { UnitComposition } from "./common";
+
+export const getAlliedCompositions = (
+    gameApi: GameApi,
+    playerData: PlayerData,
+    matchAwareness: MatchAwareness,
+): UnitComposition => {
+    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 }),
+    };
+};

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

@@ -1,3 +1,3 @@
-export type UnitComposition = {
-    [unitType: string]: number;
-};
+export type UnitComposition = {
+    [unitType: string]: number;
+};

package/src/bot/logic/composition/sovietCompositions.ts

@@ -1,21 +1,21 @@
-import { GameApi, PlayerData } from "@chronodivide/game-api";
-import { MatchAwareness } from "../awareness";
-import { UnitComposition } from "./common";
-
-export const getSovietComposition = (
-    gameApi: GameApi,
-    playerData: PlayerData,
-    matchAwareness: MatchAwareness,
-): UnitComposition => {
-    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 }),
-    };
-};
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { MatchAwareness } from "../awareness";
+import { UnitComposition } from "./common";
+
+export const getSovietComposition = (
+    gameApi: GameApi,
+    playerData: PlayerData,
+    matchAwareness: MatchAwareness,
+): UnitComposition => {
+    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 }),
+    };
+};

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

@@ -1,66 +1,66 @@
-import { GameApi, GameMath, MapApi, PlayerData, Size, Tile, UnitData, Vector2 } from "@chronodivide/game-api";
-import { maxBy } from "../common/utils.js";
-
-export function determineMapBounds(mapApi: MapApi): Size {
-    return mapApi.getRealMapSize();
-}
-
-export function calculateAreaVisibility(
-    mapApi: MapApi,
-    playerData: PlayerData,
-    startPoint: Vector2,
-    endPoint: Vector2,
-): { visibleTiles: number; validTiles: number } {
-    let validTiles: number = 0,
-        visibleTiles: number = 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: GameApi,
-    startLocation: Vector2,
-    endLocation: Vector2,
-    minRadius: number,
-    maxRadius: number,
-    randomAngle: number,
-): Vector2 {
-    // 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: Vector2, endLocation: Vector2): number {
-    // TODO: Remove this now we have Vector2s.
-    return startLocation.distanceTo(endLocation);
-}
-
-export function getDistanceBetweenTileAndPoint(tile: Tile, vector: Vector2): number {
-    // TODO: Remove this now we have Vector2s.
-    return new Vector2(tile.rx, tile.ry).distanceTo(vector);
-}
-
-export function getDistanceBetweenUnits(unit1: UnitData, unit2: UnitData): number {
-    return new Vector2(unit1.tile.rx, unit1.tile.ry).distanceTo(new Vector2(unit2.tile.rx, unit2.tile.ry));
-}
-
-export function getDistanceBetween(unit: UnitData, point: Vector2): number {
-    return getDistanceBetweenPoints(new Vector2(unit.tile.rx, unit.tile.ry), point);
-}
+import { GameApi, GameMath, MapApi, PlayerData, Size, Tile, UnitData, Vector2 } from "@chronodivide/game-api";
+import { maxBy } from "../common/utils.js";
+
+export function determineMapBounds(mapApi: MapApi): Size {
+    return mapApi.getRealMapSize();
+}
+
+export function calculateAreaVisibility(
+    mapApi: MapApi,
+    playerData: PlayerData,
+    startPoint: Vector2,
+    endPoint: Vector2,
+): { visibleTiles: number; validTiles: number } {
+    let validTiles: number = 0,
+        visibleTiles: number = 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: GameApi,
+    startLocation: Vector2,
+    endLocation: Vector2,
+    minRadius: number,
+    maxRadius: number,
+    randomAngle: number,
+): Vector2 {
+    // 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: Vector2, endLocation: Vector2): number {
+    // TODO: Remove this now we have Vector2s.
+    return startLocation.distanceTo(endLocation);
+}
+
+export function getDistanceBetweenTileAndPoint(tile: Tile, vector: Vector2): number {
+    // TODO: Remove this now we have Vector2s.
+    return new Vector2(tile.rx, tile.ry).distanceTo(vector);
+}
+
+export function getDistanceBetweenUnits(unit1: UnitData, unit2: UnitData): number {
+    return new Vector2(unit1.tile.rx, unit1.tile.ry).distanceTo(new Vector2(unit2.tile.rx, unit2.tile.ry));
+}
+
+export function getDistanceBetween(unit: UnitData, point: Vector2): number {
+    return getDistanceBetweenPoints(new Vector2(unit.tile.rx, unit.tile.ry), point);
+}