@supalosa/chronodivide-bot 0.2.0 → 0.2.2-a

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

@@ -1,17 +1,29 @@
-import { ActionsApi, GameApi, OrderType, PlayerData, Point2D, SideType } from "@chronodivide/game-api";
-import { GlobalThreat } from "../../threat/threat.js";
+import { ActionsApi, GameApi, OrderType, PlayerData, Point2D } 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 { DebugLogger } from "../../common/utils.js";
+import { getDistanceBetweenPoints } from "../../map/map.js";
 
 const SCOUT_MOVE_COOLDOWN_TICKS = 30;
 
+// Max units to spend on a particular scout target.
+const MAX_ATTEMPTS_PER_TARGET = 5;
+
+// Maximum ticks to spend trying to scout a target *without making progress towards it*.
+// Every time a unit gets closer to the target, the timer refreshes.
+const MAX_TICKS_PER_TARGET = 600;
+
 export class ScoutingSquad implements SquadBehaviour {
-    private scoutingWith: {
-        unitId: number;
-        gameTick: number;
-    } | null = null;
+    private scoutTarget: Point2D | null = null;
+    private attemptsOnCurrentTarget: number = 0;
+    private scoutTargetRefreshedAt: number = 0;
+    private lastMoveCommandTick: number = 0;
+
+    // Minimum distance from a scout to the target.
+    private scoutMinDistance?: number;
+
+    private hadUnit: boolean = false;
 
     public onAiUpdate(
         gameApi: GameApi,
@@ -19,6 +31,7 @@ export class ScoutingSquad implements SquadBehaviour {
         playerData: PlayerData,
         squad: Squad,
         matchAwareness: MatchAwareness,
+        logger: DebugLogger,
     ): SquadAction {
         const scoutNames = ["ADOG", "DOG", "E1", "E2", "FV", "HTK"];
         const scouts = squad.getUnitsOfTypes(gameApi, ...scoutNames);
@@ -28,29 +41,69 @@ export class ScoutingSquad implements SquadBehaviour {
         }
 
         if (scouts.length === 0) {
-            this.scoutingWith = null;
+            // Count the number of times the scout dies trying to uncover the current scoutTarget.
+            if (this.scoutTarget && this.hadUnit) {
+                this.attemptsOnCurrentTarget++;
+                this.hadUnit = false;
+            }
             return requestUnits(scoutNames, 100);
-        } else if (
-            !this.scoutingWith ||
-            gameApi.getCurrentTick() > this.scoutingWith.gameTick + SCOUT_MOVE_COOLDOWN_TICKS
-        ) {
-            const candidatePoints = getUnseenStartingLocations(gameApi, playerData);
-            scouts.forEach((unit) => {
-                if (candidatePoints.length > 0) {
-                    if (unit?.isIdle) {
-                        const scoutLocation =
-                            candidatePoints[Math.floor(gameApi.generateRandom() * candidatePoints.length)];
-                        actionsApi.orderUnits([unit.id], OrderType.AttackMove, scoutLocation.x, scoutLocation.y);
+        } 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();
+            }
+            const targetTile = gameApi.mapApi.getTile(this.scoutTarget.x, this.scoutTarget.y);
+            if (!targetTile) {
+                throw new Error(`target tile ${this.scoutTarget.x},${this.scoutTarget.y} does not exist`);
+            }
+            if (gameApi.getCurrentTick() > this.lastMoveCommandTick + SCOUT_MOVE_COOLDOWN_TICKS) {
+                this.lastMoveCommandTick = gameApi.getCurrentTick();
+                scouts.forEach((unit) => {
+                    if (this.scoutTarget) {
+                        actionsApi.orderUnits([unit.id], OrderType.AttackMove, this.scoutTarget.x, this.scoutTarget.y);
                     }
+                });
+                // Check that a scout is actually moving closer to the target.
+                const distances = scouts.map((unit) =>
+                    getDistanceBetweenPoints({ x: unit.tile.rx, y: unit.tile.ry }, 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})`,
+                    );
+                    this.scoutTargetRefreshedAt = gameApi.getCurrentTick();
+                    this.scoutMinDistance = newMinDistance;
                 }
-            });
-
-            // Add a cooldown to scout attempts.
-            this.scoutingWith = {
-                unitId: scouts[0].id,
-                gameTick: gameApi.getCurrentTick(),
-            };
+            }
+            if (gameApi.mapApi.isVisibleTile(targetTile, playerData.name)) {
+                logger(`Scout target ${this.scoutTarget.x},${this.scoutTarget.y} successfully scouted, moving to next`);
+                this.setScoutTarget(null, gameApi.getCurrentTick());
+            }
+        } else {
+            const candidatePoint = matchAwareness.getScoutingManager().getNewScoutTarget()?.asPoint2D();
+            if (!candidatePoint) {
+                logger(`No more scouting targets available, disbanding.`);
+                return disband();
+            }
+            this.setScoutTarget(candidatePoint, gameApi.getCurrentTick());
         }
         return noop();
     }
+
+    setScoutTarget(point: Point2D | null, currentTick: number) {
+        this.attemptsOnCurrentTarget = 0;
+        this.scoutTargetRefreshedAt = currentTick;
+        this.scoutTarget = point;
+        this.scoutMinDistance = undefined;
+    }
 }

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

@@ -4,7 +4,7 @@ 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 { DebugLogger } from "../common/utils.js";
 
 export enum SquadLiveness {
     SquadDead,
@@ -41,7 +41,7 @@ const calculateCenterOfMass: (unitTiles: Tile[]) => {
 
     // 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 maxDistance = Math.max(...distances);
     return { centerOfMass, maxDistance };
 };
 
@@ -76,6 +76,7 @@ export class Squad {
         actionsApi: ActionsApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
+        logger: DebugLogger,
     ): SquadAction {
         this.updateLiveness(gameApi);
         const movableUnitTiles = this.unitIds
@@ -100,8 +101,7 @@ export class Squad {
         } else if (!this.mission) {
             return disband();
         }
-        let outcome = this.behaviour.onAiUpdate(gameApi, actionsApi, playerData, this, matchAwareness);
-        return outcome;
+        return this.behaviour.onAiUpdate(gameApi, actionsApi, playerData, this, matchAwareness, logger);
     }
     public getMission(): Mission | null {
         return this.mission;

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

@@ -2,6 +2,7 @@ import { ActionsApi, GameApi, PlayerData, Point2D } from "@chronodivide/game-api
 import { GlobalThreat } from "../threat/threat.js";
 import { Squad } from "./squad.js";
 import { MatchAwareness } from "../awareness.js";
+import { DebugLogger } from "../common/utils.js";
 
 export type SquadActionNoop = {
     type: "noop";
@@ -56,6 +57,7 @@ export interface SquadBehaviour {
         actionsApi: ActionsApi,
         playerData: PlayerData,
         squad: Squad,
-        matchAwareness: MatchAwareness
+        matchAwareness: MatchAwareness,
+        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,6 +12,7 @@ import {
 } from "./squadBehaviour.js";
 import { MatchAwareness } from "../awareness.js";
 import { getDistanceBetween } from "../map/map.js";
+import countBy from "lodash.countby";
 
 type SquadWithAction<T> = {
     squad: Squad;
@@ -23,14 +23,13 @@ export class SquadController {
     private squads: Squad[] = [];
     private unitIdToSquad: Map<number, Squad> = new Map();
 
-    constructor() {}
+    constructor(private logger: (message: string, sayInGame?: boolean) => void) {}
 
     public onAiUpdate(
         gameApi: GameApi,
         actionsApi: ActionsApi,
         playerData: PlayerData,
         matchAwareness: MatchAwareness,
-        logger: (message: string) => void
     ) {
         // Remove dead squads or those where the mission is dead.
         this.squads = this.squads.filter((squad) => squad.getLiveness() !== SquadLiveness.SquadDead);
@@ -41,7 +40,7 @@ export class SquadController {
         this.squads.forEach((squad) => {
             squad.getUnitIds().forEach((unitId) => {
                 if (this.unitIdToSquad.has(unitId)) {
-                    logger(`WARNING: unit ${unitId} is in multiple squads, please debug.`);
+                    this.logger(`WARNING: unit ${unitId} is in multiple squads, please debug.`);
                 } else {
                     this.unitIdToSquad.set(unitId, squad);
                 }
@@ -51,7 +50,7 @@ export class SquadController {
         const squadActions: SquadWithAction<SquadAction>[] = this.squads.map((squad) => {
             return {
                 squad,
-                action: squad.onAiUpdate(gameApi, actionsApi, playerData, matchAwareness),
+                action: squad.onAiUpdate(gameApi, actionsApi, playerData, matchAwareness, this.logger),
             };
         });
         // Handle disbands and merges.
@@ -61,7 +60,7 @@ export class SquadController {
         squadActions
             .filter((a) => isDisband(a.action))
             .forEach((a) => {
-                logger(`Squad ${a.squad.getName()} disbanding as requested.`);
+                this.logger(`Squad ${a.squad.getName()} disbanding as requested.`);
                 a.squad.getMission()?.removeSquad();
                 a.squad.getUnitIds().forEach((unitId) => {
                     this.unitIdToSquad.delete(unitId);
@@ -73,8 +72,8 @@ export class SquadController {
             .forEach((a) => {
                 let mergeInto = a.action as SquadActionMergeInto;
                 if (disbandedSquads.has(mergeInto.mergeInto.getName())) {
-                    logger(
-                        `Squad ${a.squad.getName()} tried to merge into disbanded squad ${mergeInto.mergeInto.getName()}, cancelling.`
+                    this.logger(
+                        `Squad ${a.squad.getName()} tried to merge into disbanded squad ${mergeInto.mergeInto.getName()}, cancelling.`,
                     );
                     return;
                 }
@@ -88,58 +87,88 @@ export class SquadController {
         const isRequestSpecific = (a: SquadAction) => a.type === "requestSpecific";
         const unitIdToHighestRequest = squadActions
             .filter((a) => isRequestSpecific(a.action))
-            .reduce((prev, a) => {
-                const squadWithAction = a as SquadWithAction<SquadActionRequestSpecificUnits>;
-                const { unitIds } = squadWithAction.action;
-                unitIds.forEach((unitId) => {
-                    if (prev.hasOwnProperty(unitId)) {
-                        if (prev[unitId].action.priority > prev[unitId].action.priority) {
+            .reduce(
+                (prev, a) => {
+                    const squadWithAction = a as SquadWithAction<SquadActionRequestSpecificUnits>;
+                    const { unitIds } = squadWithAction.action;
+                    unitIds.forEach((unitId) => {
+                        if (prev.hasOwnProperty(unitId)) {
+                            if (prev[unitId].action.priority > prev[unitId].action.priority) {
+                                prev[unitId] = squadWithAction;
+                            }
+                        } else {
                             prev[unitId] = squadWithAction;
                         }
-                    } else {
-                        prev[unitId] = squadWithAction;
+                    });
+                    return prev;
+                },
+                {} as Record<number, SquadWithAction<SquadActionRequestSpecificUnits>>,
+            );
+
+        // Map of Squad ID to Unit Type to Count.
+        const newSquadAssignments = Object.entries(unitIdToHighestRequest)
+            .flatMap(([id, request]) => {
+                const unitId = Number.parseInt(id);
+                const unit = gameApi.getUnitData(unitId);
+                const { squad: requestingSquad } = request;
+                const missionName = requestingSquad.getMission()?.getUniqueName();
+                if (!unit) {
+                    this.logger(`mission ${missionName} requested non-existent unit ${unitId}`);
+                    return [];
+                }
+                if (!this.unitIdToSquad.has(unitId)) {
+                    this.addUnitToSquad(requestingSquad, unit);
+                    return [{ unitName: unit?.name, squad: requestingSquad.getName() }];
+                }
+                return [];
+            })
+            .reduce(
+                (acc, curr) => {
+                    if (!acc[curr.squad]) {
+                        acc[curr.squad] = {};
                     }
-                });
-                return prev;
-            }, {} as Record<number, SquadWithAction<SquadActionRequestSpecificUnits>>);
-        Object.entries(unitIdToHighestRequest).forEach(([id, request]) => {
-            const unitId = Number.parseInt(id);
-            const unit = gameApi.getUnitData(unitId);
-            const { squad: requestingSquad } = request;
-            const missionName = requestingSquad.getMission()?.getUniqueName();
-            if (!unit) {
-                logger(`mission ${missionName} requested non-existent unit ${unitId}`);
-                return;
-            }
-            if (!this.unitIdToSquad.has(unitId)) {
-                logger(`granting specific unit ${unitId} to squad ${requestingSquad.getName()} in mission ${missionName}`);
-                this.addUnitToSquad(requestingSquad, unit);
-            }
+                    if (!acc[curr.squad][curr.unitName]) {
+                        acc[curr.squad][curr.unitName] = 0;
+                    }
+                    acc[curr.squad][curr.unitName] = acc[curr.squad][curr.unitName] + 1;
+                    return acc;
+                },
+                {} as Record<string, Record<string, number>>,
+            );
+        Object.entries(newSquadAssignments).forEach(([squad, assignments]) => {
+            this.logger(
+                `Squad ${squad} received: ${Object.entries(assignments)
+                    .map(([unitType, count]) => unitType + " x " + count)
+                    .join(", ")}`,
+            );
         });
 
         // Request units by type
         const isRequest = (a: SquadAction) => a.type === "request";
         const unitTypeToHighestRequest = squadActions
             .filter((a) => isRequest(a.action))
-            .reduce((prev, a) => {
-                const squadWithAction = a as SquadWithAction<SquadActionRequestUnits>;
-                const { unitNames } = squadWithAction.action;
-                unitNames.forEach((unitName) => {
-                    if (prev.hasOwnProperty(unitName)) {
-                        if (prev[unitName].action.priority > prev[unitName].action.priority) {
+            .reduce(
+                (prev, a) => {
+                    const squadWithAction = a as SquadWithAction<SquadActionRequestUnits>;
+                    const { unitNames } = squadWithAction.action;
+                    unitNames.forEach((unitName) => {
+                        if (prev.hasOwnProperty(unitName)) {
+                            if (prev[unitName].action.priority > prev[unitName].action.priority) {
+                                prev[unitName] = squadWithAction;
+                            }
+                        } else {
                             prev[unitName] = squadWithAction;
                         }
-                    } else {
-                        prev[unitName] = squadWithAction;
-                    }
-                });
-                return prev;
-            }, {} as Record<string, SquadWithAction<SquadActionRequestUnits>>);
+                    });
+                    return prev;
+                },
+                {} as Record<string, SquadWithAction<SquadActionRequestUnits>>,
+            );
 
         // Request combat-capable units in an area
         const isGrab = (a: SquadAction) => a.type === "requestCombatants";
         const grabRequests = squadActions.filter((a) =>
-            isGrab(a.action)
+            isGrab(a.action),
         ) as SquadWithAction<SquadActionGrabFreeCombatants>[];
 
         // Find loose units
@@ -149,33 +178,57 @@ export class SquadController {
             .filter((unit) => !!unit && !this.unitIdToSquad.has(unit.id || 0))
             .map((unit) => unit!);
 
-        freeUnits.forEach((freeUnit) => {
-            if (unitTypeToHighestRequest.hasOwnProperty(freeUnit.name)) {
-                const { squad: requestingSquad } = unitTypeToHighestRequest[freeUnit.name];
-                logger(`granting unit ${freeUnit.id}#${freeUnit.name} to squad ${requestingSquad.getName()}`);
-                this.addUnitToSquad(requestingSquad, freeUnit);
-                delete unitTypeToHighestRequest[freeUnit.name];
-            } else if (grabRequests.length > 0) {
-                grabRequests.some((request) => {
-                    const { squad: requestingSquad } = request;
-                    if (
-                        freeUnit.rules.isSelectableCombatant &&
-                        getDistanceBetween(freeUnit, request.action.point) <= request.action.radius
-                    ) {
-                        logger(
-                            `granting unit ${freeUnit.id}#${
-                                freeUnit.name
-                            } to squad ${requestingSquad.getName()} via grab at ${request.action.point.x},${
-                                request.action.point.y
-                            }`
+        type AssignmentWithType = { unitName: string; squad: string; method: "type" | "grab" };
+        // [squadName][unitName]['type' | 'grab']
+        const newAssignmentsByType = freeUnits
+            .flatMap((freeUnit) => {
+                if (unitTypeToHighestRequest.hasOwnProperty(freeUnit.name)) {
+                    const { squad: requestingSquad } = unitTypeToHighestRequest[freeUnit.name];
+                    this.logger(`granting unit ${freeUnit.id}#${freeUnit.name} to squad ${requestingSquad.getName()}`);
+                    this.addUnitToSquad(requestingSquad, freeUnit);
+                    delete unitTypeToHighestRequest[freeUnit.name];
+                    return [
+                        { unitName: freeUnit.name, squad: requestingSquad.getName(), method: "type" },
+                    ] as AssignmentWithType[];
+                } else if (grabRequests.length > 0) {
+                    const grantedSquad = grabRequests.find((request) => {
+                        return (
+                            freeUnit.rules.isSelectableCombatant &&
+                            getDistanceBetween(freeUnit, request.action.point) <= request.action.radius
                         );
-                        this.addUnitToSquad(requestingSquad, freeUnit);
-                        return true;
-                    } else {
-                        return false;
+                    });
+                    if (grantedSquad) {
+                        this.addUnitToSquad(grantedSquad.squad, freeUnit);
+                        return [
+                            { unitName: freeUnit.name, squad: grantedSquad.squad.getName(), method: "grab" },
+                        ] as AssignmentWithType[];
                     }
-                });
-            }
+                }
+                return [];
+            })
+            .reduce(
+                (acc, curr) => {
+                    if (!acc[curr.squad]) {
+                        acc[curr.squad] = {};
+                    }
+                    if (!acc[curr.squad][curr.unitName]) {
+                        acc[curr.squad][curr.unitName] = { grab: 0, type: 0 };
+                    }
+                    acc[curr.squad][curr.unitName][curr.method] = acc[curr.squad][curr.unitName][curr.method] + 1;
+                    return acc;
+                },
+                {} as Record<string, Record<string, Record<"type" | "grab", number>>>,
+            );
+        Object.entries(newAssignmentsByType).forEach(([squad, assignments]) => {
+            this.logger(
+                `Squad ${squad} received: ${Object.entries(assignments)
+                    .flatMap(([unitType, methodToCount]) =>
+                        Object.entries(methodToCount)
+                            .filter(([, count]) => count > 0)
+                            .map(([method, count]) => unitType + " x " + count + " (by " + method + ")"),
+                    )
+                    .join(", ")}`,
+            );
         });
     }
 
@@ -187,4 +240,16 @@ export class SquadController {
     public registerSquad(squad: Squad) {
         this.squads.push(squad);
     }
+
+    public debugSquads(gameApi: GameApi) {
+        const unitsInSquad = (unitIds: number[]) => countBy(unitIds, (unitId) => gameApi.getUnitData(unitId)?.name);
+
+        this.squads.forEach((squad) => {
+            this.logger(
+                `Squad ${squad.getName()}: ${Object.entries(unitsInSquad(squad.getUnitIds()))
+                    .map(([unitName, count]) => `${unitName} x ${count}`)
+                    .join(", ")}`,
+            );
+        });
+    }
 }

package/src/exampleBot.ts

@@ -1,4 +1,4 @@
-import { cdapi } from "@chronodivide/game-api";
+import { Agent, Bot, cdapi } from "@chronodivide/game-api";
 import { SupalosaBot } from "./bot/bot.js";
 
 async function main() {
@@ -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 = "tn04t2.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)}`;
@@ -26,14 +26,33 @@ async function main() {
     console.log("Server URL: " + process.env.SERVER_URL!);
     console.log("Client URL: " + process.env.CLIENT_URL!);
 
-    const game = await cdapi.createGame({
-        // Uncomment the following lines to play in real time versus the bot
-        /*online: true,
+    /*
+    Countries:
+    0=Americans
+    1=Alliance -> Korea
+    2=French
+    3=Germans
+    4=British
+
+    5=Africans -> Libya
+    6=Arabs -> Iraq
+    7=Confederation -> Cuba
+    8=Russians
+    */
+
+    const onlineSettings = {
+        online: true as true,
         serverUrl: process.env.SERVER_URL!,
         clientUrl: process.env.CLIENT_URL!,
-        agents: [new SupalosaBot(botName, "Americans"), { name: otherBotName, country: "French" }],*/
-        agents: [new SupalosaBot(botName, "French", false), new SupalosaBot(otherBotName, "French", true)],
-        //agents: [new SupalosaBot(botName, "Americans", false), new SupalosaBot(otherBotName, "Russians", false)],
+        agents: [new SupalosaBot(botName, "Americans"), { name: otherBotName, country: "French" }] as [Bot, ...Agent[]],
+    };
+
+    const offlineSettings = {
+        agents: [new SupalosaBot(botName, "French", false), new SupalosaBot(otherBotName, "Russians", true)],
+    };
+
+    const game = await cdapi.createGame({
+        ...offlineSettings,
         buildOffAlly: false,
         cratesAppear: false,
         credits: 10000,