@supalosa/chronodivide-bot 0.2.2-b → 0.3.0

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

@@ -1,9 +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 { getDistanceBetweenTileAndPoint } from "../map/map.js";
 import { DebugLogger } from "../common/utils.js";
 
 export enum SquadLiveness {
@@ -18,7 +17,7 @@ export type SquadConstructionRequest = {
 };
 
 const calculateCenterOfMass: (unitTiles: Tile[]) => {
-    centerOfMass: Point2D;
+    centerOfMass: Vector2;
     maxDistance: number;
 } | null = (unitTiles) => {
     if (unitTiles.length === 0) {
@@ -34,13 +33,10 @@ 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 distances = unitTiles.map((tile) => getDistanceBetweenTileAndPoint(tile, centerOfMass));
     const maxDistance = Math.max(...distances);
     return { centerOfMass, maxDistance };
 };
@@ -49,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(

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

@@ -179,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)) {

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

@@ -1,99 +1,100 @@
-import { GameApi, MovementZone, ObjectType, PlayerData, UnitData } from "@chronodivide/game-api";
-import { GlobalThreat } from "./threat.js";
-
-export function calculateGlobalThreat(game: GameApi, playerData: PlayerData, visibleAreaPercent: number): GlobalThreat {
-    let groundUnits = game.getVisibleUnits(
-        playerData.name,
-        "hostile",
-        (r) => r.type == ObjectType.Vehicle || r.type == ObjectType.Infantry,
-    );
-    let airUnits = game.getVisibleUnits(playerData.name, "hostile", (r) => r.movementZone == MovementZone.Fly);
-    let groundDefence = game
-        .getVisibleUnits(playerData.name, "hostile", (r) => r.type == ObjectType.Building)
-        .filter((unitId) => isAntiGround(game, unitId));
-    let antiAirPower = game
-        .getVisibleUnits(playerData.name, "hostile", (r) => r.type != ObjectType.Building)
-        .filter((unitId) => isAntiAir(game, unitId));
-
-    let ourAntiGroundUnits = game
-        .getVisibleUnits(playerData.name, "self", (r) => r.isSelectableCombatant)
-        .filter((unitId) => isAntiGround(game, unitId));
-    let ourAntiAirUnits = game
-        .getVisibleUnits(playerData.name, "self", (r) => r.isSelectableCombatant)
-        .filter((unitId) => isAntiAir(game, unitId));
-    let ourGroundDefence = game
-        .getVisibleUnits(playerData.name, "self", (r) => r.type == ObjectType.Building)
-        .filter((unitId) => isAntiGround(game, unitId));
-    let ourAirUnits = game.getVisibleUnits(
-        playerData.name,
-        "self",
-        (r) => r.movementZone == MovementZone.Fly && r.isSelectableCombatant,
-    );
-
-    let observedGroundThreat = calculateFirepowerForUnits(game, groundUnits);
-    let observedAirThreat = calculateFirepowerForUnits(game, airUnits);
-    let observedAntiAirThreat = calculateFirepowerForUnits(game, antiAirPower);
-    let observedGroundDefence = calculateFirepowerForUnits(game, groundDefence);
-
-    let ourAntiGroundPower = calculateFirepowerForUnits(game, ourAntiGroundUnits);
-    let ourAntiAirPower = calculateFirepowerForUnits(game, ourAntiAirUnits);
-    let ourAirPower = calculateFirepowerForUnits(game, ourAirUnits);
-    let ourGroundDefencePower = calculateFirepowerForUnits(game, ourGroundDefence);
-
-    return new GlobalThreat(
-        visibleAreaPercent,
-        observedGroundThreat,
-        observedAirThreat,
-        observedAntiAirThreat,
-        observedGroundDefence * 0.25,
-        ourGroundDefencePower * 0.25,
-        ourAntiGroundPower,
-        ourAntiAirPower,
-        ourAirPower,
-    );
-}
-
-function isAntiGround(gameApi: GameApi, unitId: number): boolean {
-    let unit = gameApi.getUnitData(unitId);
-    if (unit && unit.primaryWeapon) {
-        return unit.primaryWeapon.projectileRules.isAntiGround;
-    }
-    return false;
-}
-
-function isAntiAir(gameApi: GameApi, unitId: number): boolean {
-    let unit = gameApi.getUnitData(unitId);
-    if (unit && unit.primaryWeapon) {
-        return unit.primaryWeapon.projectileRules.isAntiAir;
-    }
-    return false;
-}
-
-function calculateFirepowerForUnit(unitData: UnitData): number {
-    let threat = 0;
-    let hpRatio = unitData.hitPoints / Math.max(1, unitData.maxHitPoints);
-    if (unitData.primaryWeapon) {
-        threat +=
-            (hpRatio *
-                ((unitData.primaryWeapon.rules.damage + 1) * Math.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))) /
-            Math.max(unitData.secondaryWeapon.cooldownTicks, 1);
-    }
-    return Math.min(800, threat);
-}
-
-function calculateFirepowerForUnits(game: GameApi, unitIds: number[]) {
-    let threat = 0;
-    unitIds.forEach((unitId) => {
-        let unitData = game.getUnitData(unitId);
-        if (unitData) {
-            threat += calculateFirepowerForUnit(unitData);
-        }
-    });
-    return threat;
-}
+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 {
+    let groundUnits = game.getVisibleUnits(
+        playerData.name,
+        "hostile",
+        (r) => r.type == ObjectType.Vehicle || r.type == ObjectType.Infantry,
+    );
+    let airUnits = game.getVisibleUnits(playerData.name, "hostile", (r) => r.movementZone == MovementZone.Fly);
+    let groundDefence = game
+        .getVisibleUnits(playerData.name, "hostile", (r) => r.type == ObjectType.Building)
+        .filter((unitId) => isAntiGround(game, unitId));
+    let antiAirPower = game
+        .getVisibleUnits(playerData.name, "hostile", (r) => r.type != ObjectType.Building)
+        .filter((unitId) => isAntiAir(game, unitId));
+
+    let ourAntiGroundUnits = game
+        .getVisibleUnits(playerData.name, "self", (r) => r.isSelectableCombatant)
+        .filter((unitId) => isAntiGround(game, unitId));
+    let ourAntiAirUnits = game
+        .getVisibleUnits(playerData.name, "self", (r) => r.isSelectableCombatant)
+        .filter((unitId) => isAntiAir(game, unitId));
+    let ourGroundDefence = game
+        .getVisibleUnits(playerData.name, "self", (r) => r.type == ObjectType.Building)
+        .filter((unitId) => isAntiGround(game, unitId));
+    let ourAirUnits = game.getVisibleUnits(
+        playerData.name,
+        "self",
+        (r) => r.movementZone == MovementZone.Fly && r.isSelectableCombatant,
+    );
+
+    let observedGroundThreat = calculateFirepowerForUnits(game, groundUnits);
+    let observedAirThreat = calculateFirepowerForUnits(game, airUnits);
+    let observedAntiAirThreat = calculateFirepowerForUnits(game, antiAirPower);
+    let observedGroundDefence = calculateFirepowerForUnits(game, groundDefence);
+
+    let ourAntiGroundPower = calculateFirepowerForUnits(game, ourAntiGroundUnits);
+    let ourAntiAirPower = calculateFirepowerForUnits(game, ourAntiAirUnits);
+    let ourAirPower = calculateFirepowerForUnits(game, ourAirUnits);
+    let ourGroundDefencePower = calculateFirepowerForUnits(game, ourGroundDefence);
+
+    return new GlobalThreat(
+        visibleAreaPercent,
+        observedGroundThreat,
+        observedAirThreat,
+        observedAntiAirThreat,
+        observedGroundDefence * 0.25,
+        ourGroundDefencePower * 0.25,
+        ourAntiGroundPower,
+        ourAntiAirPower,
+        ourAirPower,
+    );
+}
+
+function isAntiGround(gameApi: GameApi, unitId: number): boolean {
+    let unit = gameApi.getUnitData(unitId);
+    if (unit && unit.primaryWeapon) {
+        return unit.primaryWeapon.projectileRules.isAntiGround;
+    }
+    return false;
+}
+
+function isAntiAir(gameApi: GameApi, unitId: number): boolean {
+    let unit = gameApi.getUnitData(unitId);
+    if (unit && unit.primaryWeapon) {
+        return unit.primaryWeapon.projectileRules.isAntiAir;
+    }
+    return false;
+}
+
+function calculateFirepowerForUnit(unitData: UnitData): number {
+    let threat = 0;
+    let hpRatio = unitData.hitPoints / Math.max(1, unitData.maxHitPoints);
+    if (unitData.primaryWeapon) {
+        threat +=
+            (hpRatio *
+                ((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) *
+                    GameMath.sqrt(unitData.secondaryWeapon.rules.range + 1))) /
+            Math.max(unitData.secondaryWeapon.cooldownTicks, 1);
+    }
+    return Math.min(800, threat);
+}
+
+function calculateFirepowerForUnits(game: GameApi, unitIds: number[]) {
+    let threat = 0;
+    unitIds.forEach((unitId) => {
+        let unitData = game.getUnitData(unitId);
+        if (unitData) {
+            threat += calculateFirepowerForUnit(unitData);
+        }
+    });
+    return threat;
+}

package/src/exampleBot.ts

@@ -16,7 +16,7 @@ async function main() {
     Other maps:
     mp03t4 large map, no oil derricks
     */
-    const mapName = "tn04t2.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)}`;