@supalosa/chronodivide-bot 0.2.2 → 0.3.1

package/src/bot/logic/squad/behaviours/combatSquad.ts

@@ -1,11 +1,9 @@
-import _ from "lodash";
-import { ActionsApi, GameApi, MovementZone, PlayerData, Point2D } from "@chronodivide/game-api";
+import { ActionsApi, GameApi, GameMath, MovementZone, PlayerData, UnitData, Vector2 } from "@chronodivide/game-api";
 import { Squad } from "../squad.js";
 import { SquadAction, SquadBehaviour, grabCombatants, noop } from "../squadBehaviour.js";
 import { MatchAwareness } from "../../awareness.js";
-import { getDistanceBetweenPoints } from "../../map/map.js";
-import { manageAttackMicro, manageMoveMicro } from "./common.js";
-import { DebugLogger } from "../../common/utils.js";
+import { getAttackWeight, manageAttackMicro, manageMoveMicro } from "./common.js";
+import { DebugLogger, maxBy } from "../../common/utils.js";
 
 const TARGET_UPDATE_INTERVAL_TICKS = 10;
 const GRAB_INTERVAL_TICKS = 10;
@@ -38,12 +36,12 @@ export class CombatSquad implements SquadBehaviour {
      * @param radius
      */
     constructor(
-        private rallyArea: Point2D,
-        private targetArea: Point2D,
+        private rallyArea: Vector2,
+        private targetArea: Vector2,
         private radius: number,
     ) {}
 
-    public setAttackArea(targetArea: Point2D) {
+    public setAttackArea(targetArea: Vector2) {
         this.targetArea = targetArea;
     }
 
@@ -55,7 +53,10 @@ export class CombatSquad implements SquadBehaviour {
         matchAwareness: MatchAwareness,
         logger: DebugLogger,
     ): SquadAction {
-        if (squad.getUnitIds().length > 0 && (!this.lastCommand || gameApi.getCurrentTick() > this.lastCommand + TARGET_UPDATE_INTERVAL_TICKS)) {
+        if (
+            squad.getUnitIds().length > 0 &&
+            (!this.lastCommand || gameApi.getCurrentTick() > this.lastCommand + TARGET_UPDATE_INTERVAL_TICKS)
+        ) {
             this.lastCommand = gameApi.getCurrentTick();
             const centerOfMass = squad.getCenterOfMass();
             const maxDistance = squad.getMaxDistanceToCenterOfMass();
@@ -72,7 +73,7 @@ export class CombatSquad implements SquadBehaviour {
             );
 
             if (this.state === SquadState.Gathering) {
-                const requiredGatherRadius = Math.sqrt(groundUnits.length) * GATHER_RATIO + MIN_GATHER_RADIUS;
+                const requiredGatherRadius = GameMath.sqrt(groundUnits.length) * GATHER_RATIO + MIN_GATHER_RADIUS;
                 if (
                     centerOfMass &&
                     maxDistance &&
@@ -83,12 +84,12 @@ export class CombatSquad implements SquadBehaviour {
                         manageMoveMicro(actionsApi, unit, centerOfMass);
                     });
                 } else {
-                    logger(`CombatSquad ${squad.getName()} switching back to attack mode (${maxDistance})`)
+                    logger(`CombatSquad ${squad.getName()} switching back to attack mode (${maxDistance})`);
                     this.state = SquadState.Attacking;
                 }
             } else {
                 const targetPoint = this.targetArea || playerData.startLocation;
-                const requiredGatherRadius = Math.sqrt(groundUnits.length) * GATHER_RATIO + MAX_GATHER_RADIUS;
+                const requiredGatherRadius = GameMath.sqrt(groundUnits.length) * GATHER_RATIO + MAX_GATHER_RADIUS;
                 if (
                     centerOfMass &&
                     maxDistance &&
@@ -96,24 +97,21 @@ export class CombatSquad implements SquadBehaviour {
                     maxDistance > requiredGatherRadius
                 ) {
                     // Switch back to gather mode
-                    logger(`CombatSquad ${squad.getName()} switching back to gather (${maxDistance})`)
+                    logger(`CombatSquad ${squad.getName()} switching back to gather (${maxDistance})`);
                     this.state = SquadState.Gathering;
                     return noop();
                 }
                 for (const unit of units) {
-                    if (unit.isIdle) {
-                        const { rx: x, ry: y } = unit.tile;
-                        const range = unit.primaryWeapon?.maxRange ?? unit.secondaryWeapon?.maxRange ?? 5;
-                        const nearbyHostiles = matchAwareness.getHostilesNearPoint(x, y, range * 2);
-                        const closest = _.minBy(nearbyHostiles, ({ x: hX, y: hY }) =>
-                            getDistanceBetweenPoints({ x, y }, { x: hX, y: hY }),
-                        );
-                        const closestUnit = closest ? gameApi.getUnitData(closest.unitId) ?? null : null;
-                        if (closestUnit) {
-                            manageAttackMicro(actionsApi, unit, closestUnit);
-                        } else {
-                            manageMoveMicro(actionsApi, unit, targetPoint);
-                        }
+                    const { rx: x, ry: y } = unit.tile;
+                    const range = unit.primaryWeapon?.maxRange ?? unit.secondaryWeapon?.maxRange ?? 5;
+                    const nearbyHostiles = matchAwareness
+                        .getHostilesNearPoint(x, y, range * 2)
+                        .map(({ unitId }) => gameApi.getUnitData(unitId)) as UnitData[];
+                    const bestUnit = maxBy(nearbyHostiles, (target) => getAttackWeight(unit, target));
+                    if (bestUnit) {
+                        manageAttackMicro(actionsApi, unit, bestUnit);
+                    } else {
+                        manageMoveMicro(actionsApi, unit, targetPoint);
                     }
                 }
             }

package/src/bot/logic/squad/behaviours/common.ts

@@ -1,8 +1,17 @@
-import { ActionsApi, AttackState, ObjectType, OrderType, Point2D, StanceType, UnitData } from "@chronodivide/game-api";
-import { getDistanceBetweenUnits } from "../../map/map.js";
+import {
+    ActionsApi,
+    AttackState,
+    ObjectType,
+    OrderType,
+    StanceType,
+    UnitData,
+    Vector2,
+    ZoneType,
+} from "@chronodivide/game-api";
+import { getDistanceBetweenPoints, getDistanceBetweenUnits } from "../../map/map.js";
 
 // Micro methods
-export function manageMoveMicro(actionsApi: ActionsApi, attacker: UnitData, attackPoint: Point2D) {
+export function manageMoveMicro(actionsApi: ActionsApi, attacker: UnitData, attackPoint: Vector2) {
     if (attacker.name === "E1") {
         const isDeployed = attacker.stance === StanceType.Deployed;
         if (isDeployed) {
@@ -37,3 +46,24 @@ export function manageAttackMicro(actionsApi: ActionsApi, attacker: UnitData, ta
     }
     actionsApi.orderUnits([attacker.id], orderType, target.id);
 }
+
+/**
+ *
+ * @param attacker
+ * @param target
+ * @returns A number describing the weight of the given target for the attacker, or null if it should not attack it.
+ */
+export function getAttackWeight(attacker: UnitData, target: UnitData): number | null {
+    const { rx: x, ry: y } = attacker.tile;
+    const { rx: hX, ry: hY } = target.tile;
+
+    if (!attacker.primaryWeapon?.projectileRules.isAntiAir && target.zone === ZoneType.Air) {
+        return null;
+    }
+
+    if (!attacker.primaryWeapon?.projectileRules.isAntiGround && target.zone === ZoneType.Ground) {
+        return null;
+    }
+
+    return 1000000 - getDistanceBetweenPoints(new Vector2(x, y), new Vector2(hX, hY));
+}

package/src/bot/logic/squad/behaviours/engineerSquad.ts

@@ -0,0 +1,53 @@
+import { ActionsApi, GameApi, OrderType, PlayerData, SideType } from "@chronodivide/game-api";
+import { Squad } from "../squad.js";
+import { SquadAction, SquadBehaviour, disband, noop, requestSpecificUnits, requestUnits } from "../squadBehaviour.js";
+import { MatchAwareness } from "../../awareness.js";
+
+const CAPTURE_COOLDOWN_TICKS = 30;
+
+// Capture squad
+export class EngineerSquad implements SquadBehaviour {
+    private hasAttemptedCaptureWith: {
+        unitId: number;
+        gameTick: number;
+    } | null = null;
+
+    /**
+     * @param captureTarget ID of the target to try and capture/send engineer into.
+     */
+    constructor(private captureTarget: number) {
+    };
+
+    public onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        squad: Squad,
+        matchAwareness: MatchAwareness
+    ): SquadAction {
+        const engineerTypes = ["ENGINEER", "SENGINEER"];
+        const engineers = squad.getUnitsOfTypes(gameApi, ...engineerTypes);
+        if (engineers.length === 0) {
+            // Perhaps we deployed already (or the unit was destroyed), end the mission.
+            if (this.hasAttemptedCaptureWith !== null) {
+                return disband();
+            }
+            return requestUnits(engineerTypes, 100);
+        } else if (
+            !this.hasAttemptedCaptureWith ||
+            gameApi.getCurrentTick() > this.hasAttemptedCaptureWith.gameTick + CAPTURE_COOLDOWN_TICKS
+        ) {
+            actionsApi.orderUnits(
+                engineers.map((engineer) => engineer.id),
+                OrderType.Capture,
+                this.captureTarget
+            );
+            // Add a cooldown to deploy attempts.
+            this.hasAttemptedCaptureWith = {
+                unitId: engineers[0].id,
+                gameTick: gameApi.getCurrentTick(),
+            };
+        }
+        return noop();
+    }
+}

package/src/bot/logic/squad/behaviours/retreatSquad.ts

@@ -1,4 +1,4 @@
-import { ActionsApi, GameApi, OrderType, PlayerData, Point2D, SideType } from "@chronodivide/game-api";
+import { ActionsApi, GameApi, OrderType, PlayerData, Vector2 } from "@chronodivide/game-api";
 import { GlobalThreat } from "../../threat/threat.js";
 import { Squad } from "../squad.js";
 import { SquadAction, SquadBehaviour, disband, noop, requestSpecificUnits, requestUnits } from "../squadBehaviour.js";
@@ -11,7 +11,7 @@ export class RetreatSquad implements SquadBehaviour {
 
     constructor(
         private unitIds: number[],
-        private retreatToPoint: Point2D,
+        private retreatToPoint: Vector2,
     ) {}
 
     public onAiUpdate(

package/src/bot/logic/squad/behaviours/scoutingSquad.ts

@@ -1,13 +1,10 @@
-import { ActionsApi, GameApi, OrderType, PlayerData, Point2D, SideType } from "@chronodivide/game-api";
-import { GlobalThreat } from "../../threat/threat.js";
+import { ActionsApi, GameApi, OrderType, PlayerData, Vector2 } from "@chronodivide/game-api";
 import { Squad } from "../squad.js";
 import { SquadAction, SquadBehaviour, disband, noop, requestUnits } from "../squadBehaviour.js";
 import { MatchAwareness } from "../../awareness.js";
-import { getUnseenStartingLocations } from "../../common/scout.js";
-import { match } from "assert";
 import { DebugLogger } from "../../common/utils.js";
-import _ from "lodash";
-import { getDistanceBetweenPoints, getDistanceBetweenUnits } from "../../map/map.js";
+import { getDistanceBetweenTileAndPoint } from "../../map/map.js";
+import { PrioritisedScoutTarget } from "../../common/scout.js";
 
 const SCOUT_MOVE_COOLDOWN_TICKS = 30;
 
@@ -19,10 +16,11 @@ const MAX_ATTEMPTS_PER_TARGET = 5;
 const MAX_TICKS_PER_TARGET = 600;
 
 export class ScoutingSquad implements SquadBehaviour {
-    private scoutTarget: Point2D | null = null;
+    private scoutTarget: Vector2 | null = null;
     private attemptsOnCurrentTarget: number = 0;
     private scoutTargetRefreshedAt: number = 0;
     private lastMoveCommandTick: number = 0;
+    private scoutTargetIsPermanent: boolean = false;
 
     // Minimum distance from a scout to the target.
     private scoutMinDistance?: number;
@@ -53,17 +51,19 @@ export class ScoutingSquad implements SquadBehaviour {
             return requestUnits(scoutNames, 100);
         } else if (this.scoutTarget) {
             this.hadUnit = true;
-            if (this.attemptsOnCurrentTarget > MAX_ATTEMPTS_PER_TARGET) {
-                logger(
-                    `Scout target ${this.scoutTarget.x},${this.scoutTarget.y} took too many attempts, moving to next`,
-                );
-                this.setScoutTarget(null, 0);
-                return noop();
-            }
-            if (gameApi.getCurrentTick() > this.scoutTargetRefreshedAt + MAX_TICKS_PER_TARGET) {
-                logger(`Scout target ${this.scoutTarget.x},${this.scoutTarget.y} took too long, moving to next`);
-                this.setScoutTarget(null, 0);
-                return noop();
+            if (!this.scoutTargetIsPermanent) {
+                if (this.attemptsOnCurrentTarget > MAX_ATTEMPTS_PER_TARGET) {
+                    logger(
+                        `Scout target ${this.scoutTarget.x},${this.scoutTarget.y} took too many attempts, moving to next`,
+                    );
+                    this.setScoutTarget(null, 0);
+                    return noop();
+                }
+                if (gameApi.getCurrentTick() > this.scoutTargetRefreshedAt + MAX_TICKS_PER_TARGET) {
+                    logger(`Scout target ${this.scoutTarget.x},${this.scoutTarget.y} took too long, moving to next`);
+                    this.setScoutTarget(null, 0);
+                    return noop();
+                }
             }
             const targetTile = gameApi.mapApi.getTile(this.scoutTarget.x, this.scoutTarget.y);
             if (!targetTile) {
@@ -77,11 +77,8 @@ export class ScoutingSquad implements SquadBehaviour {
                     }
                 });
                 // Check that a scout is actually moving closer to the target.
-                const newMinDistance = _.min(
-                    scouts.map((unit) =>
-                        getDistanceBetweenPoints({ x: unit.tile.rx, y: unit.tile.ry }, this.scoutTarget!),
-                    ),
-                )!;
+                const distances = scouts.map((unit) => getDistanceBetweenTileAndPoint(unit.tile, this.scoutTarget!));
+                const newMinDistance = Math.min(...distances);
                 if (!this.scoutMinDistance || newMinDistance < this.scoutMinDistance) {
                     logger(
                         `Scout timeout refreshed because unit moved closer to point (${newMinDistance} < ${this.scoutMinDistance})`,
@@ -95,20 +92,21 @@ export class ScoutingSquad implements SquadBehaviour {
                 this.setScoutTarget(null, gameApi.getCurrentTick());
             }
         } else {
-            const candidatePoint = matchAwareness.getScoutingManager().getNewScoutTarget()?.asPoint2D();
-            if (!candidatePoint) {
+            const nextScoutTarget = matchAwareness.getScoutingManager().getNewScoutTarget();
+            if (!nextScoutTarget) {
                 logger(`No more scouting targets available, disbanding.`);
                 return disband();
             }
-            this.setScoutTarget(candidatePoint, gameApi.getCurrentTick());
+            this.setScoutTarget(nextScoutTarget, gameApi.getCurrentTick());
         }
         return noop();
     }
 
-    setScoutTarget(point: Point2D | null, currentTick: number) {
+    setScoutTarget(target: PrioritisedScoutTarget | null, currentTick: number) {
         this.attemptsOnCurrentTarget = 0;
         this.scoutTargetRefreshedAt = currentTick;
-        this.scoutTarget = point;
+        this.scoutTarget = target?.asVector2() ?? null;
         this.scoutMinDistance = undefined;
+        this.scoutTargetIsPermanent = target?.isPermanent ?? false;
     }
 }

package/src/bot/logic/squad/squad.ts

@@ -1,10 +1,8 @@
-import { ActionsApi, GameApi, PlayerData, Point2D, TechnoRules, Tile, UnitData } from "@chronodivide/game-api";
+import { ActionsApi, GameApi, PlayerData, TechnoRules, Tile, UnitData, Vector2 } from "@chronodivide/game-api";
 import { Mission } from "../mission/mission.js";
-import { GlobalThreat } from "../threat/threat.js";
 import { SquadAction, SquadBehaviour, disband } from "./squadBehaviour.js";
 import { MatchAwareness } from "../awareness.js";
-import { getDistanceBetweenPoints } from "../map/map.js";
-import _ from "lodash";
+import { getDistanceBetweenTileAndPoint } from "../map/map.js";
 import { DebugLogger } from "../common/utils.js";
 
 export enum SquadLiveness {
@@ -19,7 +17,7 @@ export type SquadConstructionRequest = {
 };
 
 const calculateCenterOfMass: (unitTiles: Tile[]) => {
-    centerOfMass: Point2D;
+    centerOfMass: Vector2;
     maxDistance: number;
 } | null = (unitTiles) => {
     if (unitTiles.length === 0) {
@@ -35,14 +33,11 @@ const calculateCenterOfMass: (unitTiles: Tile[]) => {
         },
         { x: 0, y: 0 },
     );
-    const centerOfMass = {
-        x: Math.round(sums.x / unitTiles.length),
-        y: Math.round(sums.y / unitTiles.length),
-    };
+    const centerOfMass = new Vector2(Math.round(sums.x / unitTiles.length), Math.round(sums.y / unitTiles.length));
 
     // max distance of units to the center of mass
-    const distances = unitTiles.map((tile) => getDistanceBetweenPoints({ x: tile.rx, y: tile.ry }, centerOfMass));
-    const maxDistance = _.max(distances)!;
+    const distances = unitTiles.map((tile) => getDistanceBetweenTileAndPoint(tile, centerOfMass));
+    const maxDistance = Math.max(...distances);
     return { centerOfMass, maxDistance };
 };
 
@@ -50,7 +45,7 @@ export class Squad {
     private unitIds: number[] = [];
     private liveness: SquadLiveness = SquadLiveness.SquadActive;
     private lastLivenessUpdateTick: number = 0;
-    private centerOfMass: Point2D | null = null;
+    private centerOfMass: Vector2 | null = null;
     private maxDistanceToCenterOfMass: number | null = null;
 
     constructor(
@@ -77,7 +72,7 @@ export class Squad {
         actionsApi: ActionsApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
-        logger: DebugLogger
+        logger: DebugLogger,
     ): SquadAction {
         this.updateLiveness(gameApi);
         const movableUnitTiles = this.unitIds

package/src/bot/logic/squad/squadBehaviour.ts

@@ -1,5 +1,4 @@
-import { ActionsApi, GameApi, PlayerData, Point2D } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
+import { ActionsApi, GameApi, PlayerData, Vector2 } from "@chronodivide/game-api";
 import { Squad } from "./squad.js";
 import { MatchAwareness } from "../awareness.js";
 import { DebugLogger } from "../common/utils.js";
@@ -26,22 +25,22 @@ export type SquadActionRequestSpecificUnits = {
 };
 export type SquadActionGrabFreeCombatants = {
     type: "requestCombatants";
-    point: Point2D;
+    point: Vector2;
     radius: number;
 };
 
-export const noop = () => ({ type: "noop" } as SquadActionNoop);
+export const noop = () => ({ type: "noop" }) as SquadActionNoop;
 
-export const disband = () => ({ type: "disband" } as SquadActionDisband);
+export const disband = () => ({ type: "disband" }) as SquadActionDisband;
 
 export const requestUnits = (unitNames: string[], priority: number) =>
-    ({ type: "request", unitNames, priority } as SquadActionRequestUnits);
+    ({ type: "request", unitNames, priority }) as SquadActionRequestUnits;
 
 export const requestSpecificUnits = (unitIds: number[], priority: number) =>
-    ({ type: "requestSpecific", unitIds, priority } as SquadActionRequestSpecificUnits);
+    ({ type: "requestSpecific", unitIds, priority }) as SquadActionRequestSpecificUnits;
 
-export const grabCombatants = (point: Point2D, radius: number) =>
-    ({ type: "requestCombatants", point, radius } as SquadActionGrabFreeCombatants);
+export const grabCombatants = (point: Vector2, radius: number) =>
+    ({ type: "requestCombatants", point, radius }) as SquadActionGrabFreeCombatants;
 
 export type SquadAction =
     | SquadActionNoop
@@ -58,6 +57,6 @@ export interface SquadBehaviour {
         playerData: PlayerData,
         squad: Squad,
         matchAwareness: MatchAwareness,
-        logger: DebugLogger
+        logger: DebugLogger,
     ): SquadAction;
 }

package/src/bot/logic/squad/squadController.ts

@@ -1,7 +1,6 @@
 // Meta-controller for forming and controlling squads.
 
 import { ActionsApi, GameApi, PlayerData, UnitData } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
 import { Squad, SquadLiveness } from "./squad.js";
 import {
     SquadAction,
@@ -13,8 +12,7 @@ import {
 } from "./squadBehaviour.js";
 import { MatchAwareness } from "../awareness.js";
 import { getDistanceBetween } from "../map/map.js";
-import _ from "lodash";
-import { DebugLogger } from "../common/utils.js";
+import { countBy } from "../common/utils.js";
 
 type SquadWithAction<T> = {
     squad: Squad;
@@ -181,7 +179,6 @@ export class SquadController {
             .map((unit) => unit!);
 
         type AssignmentWithType = { unitName: string; squad: string; method: "type" | "grab" };
-        // [squadName][unitName]['type' | 'grab']
         const newAssignmentsByType = freeUnits
             .flatMap((freeUnit) => {
                 if (unitTypeToHighestRequest.hasOwnProperty(freeUnit.name)) {
@@ -244,7 +241,7 @@ export class SquadController {
     }
 
     public debugSquads(gameApi: GameApi) {
-        const unitsInSquad = (unitIds: number[]) => _.countBy(unitIds, (unitId) => gameApi.getUnitData(unitId)?.name);
+        const unitsInSquad = (unitIds: number[]) => countBy(unitIds, (unitId) => gameApi.getUnitData(unitId)?.name);
 
         this.squads.forEach((squad) => {
             this.logger(

package/src/bot/logic/threat/threat.ts

@@ -1,15 +1,15 @@
-// A periodically-refreshed cache of known threats to a bot so we can use it in decision making.
-
-export class GlobalThreat {
-    constructor(
-        public certainty: number, // 0.0 - 1.0 based on approximate visibility around the map.
-        public totalOffensiveLandThreat: number, // a number that approximates how much land-based firepower our opponents have.
-        public totalOffensiveAirThreat: number, // a number that approximates how much airborne firepower our opponents have.
-        public totalOffensiveAntiAirThreat: number, // a number that approximates how much anti-air firepower our opponents have.
-        public totalDefensiveThreat: number, // a number that approximates how much defensive power our opponents have.
-        public totalDefensivePower: number, // a number that approximates how much defensive power we have.
-        public totalAvailableAntiGroundFirepower: number, // how much anti-ground power we have
-        public totalAvailableAntiAirFirepower: number, // how much anti-air power we have
-        public totalAvailableAirPower: number, // how much firepower we have in air units
-    ) {}
-}
+// A periodically-refreshed cache of known threats to a bot so we can use it in decision making.
+
+export class GlobalThreat {
+    constructor(
+        public certainty: number, // 0.0 - 1.0 based on approximate visibility around the map.
+        public totalOffensiveLandThreat: number, // a number that approximates how much land-based firepower our opponents have.
+        public totalOffensiveAirThreat: number, // a number that approximates how much airborne firepower our opponents have.
+        public totalOffensiveAntiAirThreat: number, // a number that approximates how much anti-air firepower our opponents have.
+        public totalDefensiveThreat: number, // a number that approximates how much defensive power our opponents have.
+        public totalDefensivePower: number, // a number that approximates how much defensive power we have.
+        public totalAvailableAntiGroundFirepower: number, // how much anti-ground power we have
+        public totalAvailableAntiAirFirepower: number, // how much anti-air power we have
+        public totalAvailableAirPower: number, // how much firepower we have in air units
+    ) {}
+}

package/src/bot/logic/threat/threatCalculator.ts

@@ -1,4 +1,4 @@
-import { GameApi, MovementZone, ObjectType, PlayerData, UnitData } from "@chronodivide/game-api";
+import { GameApi, GameMath, MovementZone, ObjectType, PlayerData, UnitData } from "@chronodivide/game-api";
 import { GlobalThreat } from "./threat.js";
 
 export function calculateGlobalThreat(game: GameApi, playerData: PlayerData, visibleAreaPercent: number): GlobalThreat {
@@ -75,13 +75,14 @@ function calculateFirepowerForUnit(unitData: UnitData): number {
     if (unitData.primaryWeapon) {
         threat +=
             (hpRatio *
-                ((unitData.primaryWeapon.rules.damage + 1) * Math.sqrt(unitData.primaryWeapon.rules.range + 1))) /
+                ((unitData.primaryWeapon.rules.damage + 1) * GameMath.sqrt(unitData.primaryWeapon.rules.range + 1))) /
             Math.max(unitData.primaryWeapon.cooldownTicks, 1);
     }
     if (unitData.secondaryWeapon) {
         threat +=
             (hpRatio *
-                ((unitData.secondaryWeapon.rules.damage + 1) * Math.sqrt(unitData.secondaryWeapon.rules.range + 1))) /
+                ((unitData.secondaryWeapon.rules.damage + 1) *
+                    GameMath.sqrt(unitData.secondaryWeapon.rules.range + 1))) /
             Math.max(unitData.secondaryWeapon.cooldownTicks, 1);
     }
     return Math.min(800, threat);

package/src/exampleBot.ts

@@ -6,17 +6,17 @@ async function main() {
     Ladder maps:
     CDR2            1v1             2_malibu_cliffs_le.map
     CDR2            1v1             4_country_swing_le_v2.map
-    CDR2            1v1             mp01t4.map
-    CDR2            1v1             tn04t2.map
-    CDR2            1v1             mp10s4.map
+    CDR2            1v1             mp01t4.map, large map, oil derricks
+    CDR2            1v1             tn04t2.map, small map
+    CDR2            1v1             mp10s4.map <- depth charge, naval map (not supported)
     CDR2            1v1             heckcorners.map
     CDR2            1v1             4_montana_dmz_le.map
     CDR2            1v1             barrel.map
     
     Other maps:
-    mp03t4
+    mp03t4 large map, no oil derricks
     */
-    const mapName = "mp01t4.map";
+    const mapName = "mp10s4.map";
     // Bot names must be unique in online mode
     const botName = `Joe${String(Date.now()).substr(-6)}`;
     const otherBotName = `Bob${String(Date.now() + 1).substr(-6)}`;
@@ -48,7 +48,7 @@ async function main() {
     };
 
     const offlineSettings = {
-        agents: [new SupalosaBot(botName, "French", false), new SupalosaBot(otherBotName, "French", true)],
+        agents: [new SupalosaBot(botName, "French", false), new SupalosaBot(otherBotName, "Russians", true)],
     };
 
     const game = await cdapi.createGame({