@supalosa/chronodivide-bot 0.1.1 → 0.2.0

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

@@ -1,66 +1,190 @@
-// Meta-controller for forming and controlling squads.
-
-import { GameApi, PlayerData } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
-import { Squad, SquadLiveness } from "./squad.js";
-import { SquadAction, SquadActionDisband, SquadActionMergeInto } from "./squadBehaviour.js";
-
-export class SquadController {
-    constructor(
-        private squads: Squad[] = [],
-        private unitIdToSquad: Map<number, Squad> = new Map(),
-    ) {}
-
-    public onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat | undefined) {
-        // Remove dead squads.
-        this.squads = this.squads.filter((squad) => squad.getLiveness() == SquadLiveness.SquadDead);
-        this.squads.sort((a, b) => a.getName().localeCompare(b.getName()));
-
-        // Check for units in multiple squads, this shouldn't happen.
-        this.unitIdToSquad = new Map();
-        this.squads.forEach((squad) => {
-            squad.getUnitIds().forEach((unitId) => {
-                if (this.unitIdToSquad.has(unitId)) {
-                    console.log(`WARNING: unit ${unitId} is in multiple squads, please debug.`);
-                } else {
-                    this.unitIdToSquad.set(unitId, squad);
-                }
-            });
-        });
-
-        let squadActions = this.squads.map((squad) => {
-            return {
-                squad,
-                action: squad.onAiUpdate(gameApi, playerData, threatData),
-            };
-        });
-        // Handle disbands and merges.
-        const isDisband = (a: SquadAction): a is SquadActionDisband => a.type == "disband";
-        const isMerge = (a: SquadAction): a is SquadActionMergeInto => a.type == "mergeInto";
-        let disbandedSquads: Set<string> = new Set();
-        squadActions
-            .filter((a) => isDisband(a.action))
-            .forEach((a) => {
-                a.squad.getUnitIds().forEach((unitId) => {
-                    this.unitIdToSquad.delete(unitId);
-                });
-                a.squad.clearUnits();
-                disbandedSquads.add(a.squad.getName());
-            });
-        squadActions
-            .filter((a) => isMerge(a.action))
-            .forEach((a) => {
-                let mergeInto = a.action as SquadActionMergeInto;
-                if (disbandedSquads.has(mergeInto.mergeInto.getName())) {
-                    console.log("Merging into a disbanded squad, cancelling.");
-                    return;
-                }
-                a.squad.getUnitIds().forEach((unitId) => mergeInto.mergeInto.addUnit(unitId));
-                disbandedSquads.add(a.squad.getName());
-            });
-        // remove disbanded and merged squads.
-        this.squads.filter((squad) => !disbandedSquads.has(squad.getName()));
-
-        // Form squads.
-    }
-}
+// 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,
+    SquadActionDisband,
+    SquadActionGrabFreeCombatants,
+    SquadActionMergeInto,
+    SquadActionRequestSpecificUnits,
+    SquadActionRequestUnits,
+} from "./squadBehaviour.js";
+import { MatchAwareness } from "../awareness.js";
+import { getDistanceBetween } from "../map/map.js";
+
+type SquadWithAction<T> = {
+    squad: Squad;
+    action: T;
+};
+
+export class SquadController {
+    private squads: Squad[] = [];
+    private unitIdToSquad: Map<number, Squad> = new Map();
+
+    constructor() {}
+
+    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);
+        this.squads.sort((a, b) => a.getName().localeCompare(b.getName()));
+
+        // Check for units in multiple squads, this shouldn't happen.
+        this.unitIdToSquad = new Map();
+        this.squads.forEach((squad) => {
+            squad.getUnitIds().forEach((unitId) => {
+                if (this.unitIdToSquad.has(unitId)) {
+                    logger(`WARNING: unit ${unitId} is in multiple squads, please debug.`);
+                } else {
+                    this.unitIdToSquad.set(unitId, squad);
+                }
+            });
+        });
+
+        const squadActions: SquadWithAction<SquadAction>[] = this.squads.map((squad) => {
+            return {
+                squad,
+                action: squad.onAiUpdate(gameApi, actionsApi, playerData, matchAwareness),
+            };
+        });
+        // Handle disbands and merges.
+        const isDisband = (a: SquadAction): a is SquadActionDisband => a.type === "disband";
+        const isMerge = (a: SquadAction): a is SquadActionMergeInto => a.type === "mergeInto";
+        let disbandedSquads: Set<string> = new Set();
+        squadActions
+            .filter((a) => isDisband(a.action))
+            .forEach((a) => {
+                logger(`Squad ${a.squad.getName()} disbanding as requested.`);
+                a.squad.getMission()?.removeSquad();
+                a.squad.getUnitIds().forEach((unitId) => {
+                    this.unitIdToSquad.delete(unitId);
+                });
+                disbandedSquads.add(a.squad.getName());
+            });
+        squadActions
+            .filter((a) => isMerge(a.action))
+            .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.`
+                    );
+                    return;
+                }
+                a.squad.getUnitIds().forEach((unitId) => mergeInto.mergeInto.addUnit(unitId));
+                disbandedSquads.add(a.squad.getName());
+            });
+        // remove disbanded and merged squads.
+        this.squads = this.squads.filter((squad) => !disbandedSquads.has(squad.getName()));
+
+        // Request specific units by ID
+        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) {
+                            prev[unitId] = squadWithAction;
+                        }
+                    } else {
+                        prev[unitId] = squadWithAction;
+                    }
+                });
+                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);
+            }
+        });
+
+        // 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) {
+                            prev[unitName] = squadWithAction;
+                        }
+                    } else {
+                        prev[unitName] = squadWithAction;
+                    }
+                });
+                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)
+        ) as SquadWithAction<SquadActionGrabFreeCombatants>[];
+
+        // Find loose units
+        const unitIds = gameApi.getVisibleUnits(playerData.name, "self");
+        const freeUnits = unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .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
+                            }`
+                        );
+                        this.addUnitToSquad(requestingSquad, freeUnit);
+                        return true;
+                    } else {
+                        return false;
+                    }
+                });
+            }
+        });
+    }
+
+    private addUnitToSquad(squad: Squad, unit: UnitData) {
+        squad.addUnit(unit.id);
+        this.unitIdToSquad.set(unit.id, squad);
+    }
+
+    public registerSquad(squad: Squad) {
+        this.squads.push(squad);
+    }
+}

package/src/exampleBot.ts

@@ -2,7 +2,21 @@ import { cdapi } from "@chronodivide/game-api";
 import { SupalosaBot } from "./bot/bot.js";
 
 async function main() {
-    const mapName = "mp03t4.map";
+    /*
+    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             heckcorners.map
+    CDR2            1v1             4_montana_dmz_le.map
+    CDR2            1v1             barrel.map
+    
+    Other maps:
+    mp03t4
+    */
+    const mapName = "mp01t4.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)}`;
@@ -14,11 +28,12 @@ async function main() {
 
     const game = await cdapi.createGame({
         // Uncomment the following lines to play in real time versus the bot
-        online: true,
+        /*online: true,
         serverUrl: process.env.SERVER_URL!,
         clientUrl: process.env.CLIENT_URL!,
-        agents: [new SupalosaBot(botName, "Americans"), { name: otherBotName, country: "French" }],
-        //agents: [new ExampleBot(botName, "Russians", false), new ExampleBot(otherBotName, "Americans", true)],
+        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)],
         buildOffAlly: false,
         cratesAppear: false,
         credits: 10000,

package/tsconfig.json

@@ -45,7 +45,7 @@
 
         /* Module Resolution Options */
         "moduleResolution": "node" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */,
-        // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
+        //"baseUrl": "./" /* Base directory to resolve non-absolute module names. */,
         // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
         // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
         // "typeRoots": [],                             /* List of folders to include type definitions from. */

package/src/bot/logic/mission/basicMission.ts

@@ -1,42 +0,0 @@
-import { GameApi, PlayerData } from "@chronodivide/game-api";
-import { Squad } from "../squad/squad.js";
-import { GlobalThreat } from "../threat/threat.js";
-import { Mission, MissionAction, MissionActionNoop, MissionFactory } from "./mission.js";
-
-// A basic mission requests specific units and does nothing with them. It is not recommended
-// to actually create this in a game as they'll just sit around idle.
-export class BasicMission implements Mission {
-    constructor(
-        private uniqueName: string,
-        private priority: number = 1,
-        private squads: Squad[] = [],
-    ) {}
-
-    getUniqueName(): string {
-        return this.uniqueName;
-    }
-
-    isActive(): boolean {
-        return true;
-    }
-
-    removeSquad(squad: Squad): void {
-        this.squads = this.squads.filter((s) => s != squad);
-    }
-
-    addSquad(squad: Squad): void {
-        if (!this.squads.find((s) => s == squad)) {
-            this.squads.push(squad);
-        }
-    }
-
-    getSquads(): Squad[] {
-        return this.squads;
-    }
-
-    onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat): MissionAction {
-        return {} as MissionActionNoop;
-    }
-
-    onSquadAdded(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat): void {}
-}

package/src/bot/logic/mission/expansionMission.ts

@@ -1,25 +0,0 @@
-import { GameApi, PlayerData } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
-import { BasicMission } from "./basicMission.js";
-import { Mission, MissionAction, MissionActionNoop, MissionFactory } from "./mission";
-
-export class ExpansionMission extends BasicMission {
-    constructor(uniqueName: string, priority: number) {
-        super(uniqueName, priority);
-    }
-
-    onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat): MissionAction {
-        return {} as MissionActionNoop;
-    }
-}
-
-export class ExpansionMissionFactory implements MissionFactory {
-    maybeCreateMission(
-        gameApi: GameApi,
-        playerData: PlayerData,
-        threatData: GlobalThreat | undefined,
-        existingMissions: Mission[],
-    ): Mission | undefined {
-        return new ExpansionMission("expansion", 10);
-    }
-}

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

@@ -1,33 +0,0 @@
-import { GameApi, PlayerData, SideType, TechnoRules } from "@chronodivide/game-api";
-import { GlobalThreat } from "../../threat/threat.js";
-import { Squad } from "../squad.js";
-import { SquadAction, SquadActionNoop, SquadBehaviour } from "../squadBehaviour.js";
-
-// Expansion or initial base.
-export class SquadExpansion implements SquadBehaviour {
-    public getDesiredComposition(
-        gameApi: GameApi,
-        playerData: PlayerData,
-        squad: Squad,
-        threatData: GlobalThreat | undefined,
-    ): { unitName: string; priority: number; amount: number }[] {
-        // This squad desires an MCV.
-        let myMcvName = playerData.country?.side == SideType.GDI ? "AMCV" : "SMCV";
-        return [
-            {
-                unitName: myMcvName,
-                priority: 10,
-                amount: 1,
-            },
-        ];
-    }
-
-    public onAiUpdate(
-        gameApi: GameApi,
-        playerData: PlayerData,
-        squad: Squad,
-        threatData: GlobalThreat | undefined,
-    ): SquadAction {
-        return {} as SquadActionNoop;
-    }
-}