@supalosa/chronodivide-bot 0.1.0 → 0.2.0

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

@@ -1,130 +1,136 @@
-// A sector is a uniform-sized segment of the map.
-
-import { MapApi, PlayerData, Point2D, Tile } from "@chronodivide/game-api";
-import { calculateAreaVisibility } from "./map.js";
-
-export const SECTOR_SIZE = 8;
-
-export class Sector {
-    constructor(
-        public sectorStartPoint: Point2D,
-        public sectorStartTile: Tile | undefined,
-        public sectorVisibilityPct: number | undefined,
-        public sectorVisibilityLastCheckTick: number | undefined,
-    ) {}
-}
-
-export class SectorCache {
-    private sectors: Sector[][] = [];
-    private mapBounds: Point2D;
-    private sectorsX: number;
-    private sectorsY: number;
-    private lastUpdatedSectorX: number | undefined;
-    private lastUpdatedSectorY: number | undefined;
-
-    constructor(mapApi: MapApi, mapBounds: Point2D) {
-        this.mapBounds = mapBounds;
-        this.sectorsX = Math.ceil(mapBounds.x / SECTOR_SIZE);
-        this.sectorsY = Math.ceil(mapBounds.y / SECTOR_SIZE);
-        this.sectors = new Array(this.sectorsX);
-        for (let xx = 0; xx < this.sectorsX; ++xx) {
-            this.sectors[xx] = new Array(this.sectorsY);
-            for (let yy = 0; yy < this.sectorsY; ++yy) {
-                this.sectors[xx][yy] = new Sector(
-                    { x: xx * SECTOR_SIZE, y: yy * SECTOR_SIZE },
-                    mapApi.getTile(xx * SECTOR_SIZE, yy * SECTOR_SIZE),
-                    undefined,
-                    undefined,
-                );
-            }
-        }
-    }
-
-    public updateSectors(currentGameTick: number, maxSectorsToUpdate: number, mapApi: MapApi, playerData: PlayerData) {
-        let nextSectorX = this.lastUpdatedSectorX ? this.lastUpdatedSectorX + 1 : 0;
-        let nextSectorY = this.lastUpdatedSectorY ? this.lastUpdatedSectorY : 0;
-        let updatedThisCycle = 0;
-
-        while (updatedThisCycle < maxSectorsToUpdate) {
-            if (nextSectorX >= this.sectorsX) {
-                nextSectorX = 0;
-                ++nextSectorY;
-            }
-            if (nextSectorY >= this.sectorsY) {
-                nextSectorY = 0;
-                nextSectorX = 0;
-            }
-            let sector: Sector | undefined = this.getSector(nextSectorX, nextSectorY);
-            if (sector) {
-                sector.sectorVisibilityLastCheckTick = currentGameTick;
-                let sp = sector.sectorStartPoint;
-                let ep = {
-                    x: sector.sectorStartPoint.x + SECTOR_SIZE,
-                    y: sector.sectorStartPoint.y + SECTOR_SIZE,
-                };
-                let visibility = calculateAreaVisibility(mapApi, playerData, sp, ep);
-                if (visibility.validTiles > 0) {
-                    sector.sectorVisibilityPct = visibility.visibleTiles / visibility.validTiles;
-                } else {
-                    sector.sectorVisibilityPct = undefined;
-                }
-            }
-            this.lastUpdatedSectorX = nextSectorX;
-            this.lastUpdatedSectorY = nextSectorY;
-            ++nextSectorX;
-            ++updatedThisCycle;
-        }
-    }
-
-    // Return % of sectors that are updated.
-    public getSectorUpdateRatio(sectorsUpdatedSinceGameTick: number): number {
-        let updated = 0,
-            total = 0;
-        for (let xx = 0; xx < this.sectorsX; ++xx) {
-            for (let yy = 0; yy < this.sectorsY; ++yy) {
-                let sector: Sector = this.sectors[xx][yy];
-                if (
-                    sector &&
-                    sector.sectorVisibilityLastCheckTick &&
-                    sector.sectorVisibilityLastCheckTick >= sectorsUpdatedSinceGameTick
-                ) {
-                    ++updated;
-                }
-                ++total;
-            }
-        }
-        return updated / total;
-    }
-
-    // Return % of tiles that are visible. Returns undefined if we haven't scanned the whole map yet.
-    public getOverallVisibility(): number | undefined {
-        let visible = 0,
-            total = 0;
-        for (let xx = 0; xx < this.sectorsX; ++xx) {
-            for (let yy = 0; yy < this.sectorsY; ++yy) {
-                let sector: Sector = this.sectors[xx][yy];
-
-                // Undefined visibility.
-                if (sector.sectorVisibilityPct != undefined) {
-                    visible += sector.sectorVisibilityPct;
-                    total += 1.0;
-                }
-            }
-        }
-        return visible / total;
-    }
-
-    public getSector(sectorX: number, sectorY: number): Sector | undefined {
-        if (sectorX < 0 || sectorX >= this.sectorsX || sectorY < 0 || sectorY >= this.sectorsY) {
-            return undefined;
-        }
-        return this.sectors[sectorX][sectorY];
-    }
-
-    public getSectorForWorldPosition(x: number, y: number): Sector | undefined {
-        if (x < 0 || x >= this.mapBounds.x || y < 0 || y >= this.mapBounds.y) {
-            return undefined;
-        }
-        return this.sectors[Math.floor(x / SECTOR_SIZE)][Math.floor(y / SECTOR_SIZE)];
-    }
-}
+// A sector is a uniform-sized segment of the map.
+
+import { MapApi, PlayerData, Point2D, Tile } from "@chronodivide/game-api";
+import { calculateAreaVisibility } from "./map.js";
+
+export const SECTOR_SIZE = 8;
+
+export class Sector {
+    constructor(
+        public sectorStartPoint: Point2D,
+        public sectorStartTile: Tile | undefined,
+        public sectorVisibilityPct: number | undefined,
+        public sectorVisibilityLastCheckTick: number | undefined
+    ) {}
+}
+
+export class SectorCache {
+    private sectors: Sector[][] = [];
+    private mapBounds: Point2D;
+    private sectorsX: number;
+    private sectorsY: number;
+    private lastUpdatedSectorX: number | undefined;
+    private lastUpdatedSectorY: number | undefined;
+
+    constructor(mapApi: MapApi, mapBounds: Point2D) {
+        this.mapBounds = mapBounds;
+        this.sectorsX = Math.ceil(mapBounds.x / SECTOR_SIZE);
+        this.sectorsY = Math.ceil(mapBounds.y / SECTOR_SIZE);
+        this.sectors = new Array(this.sectorsX);
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            this.sectors[xx] = new Array(this.sectorsY);
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                this.sectors[xx][yy] = new Sector(
+                    { x: xx * SECTOR_SIZE, y: yy * SECTOR_SIZE },
+                    mapApi.getTile(xx * SECTOR_SIZE, yy * SECTOR_SIZE),
+                    undefined,
+                    undefined
+                );
+            }
+        }
+    }
+
+    public getMapBounds(): Point2D {
+        return this.mapBounds;
+    }
+
+    public updateSectors(currentGameTick: number, maxSectorsToUpdate: number, mapApi: MapApi, playerData: PlayerData) {
+        let nextSectorX = this.lastUpdatedSectorX ? this.lastUpdatedSectorX + 1 : 0;
+        let nextSectorY = this.lastUpdatedSectorY ? this.lastUpdatedSectorY : 0;
+        let updatedThisCycle = 0;
+
+        while (updatedThisCycle < maxSectorsToUpdate) {
+            if (nextSectorX >= this.sectorsX) {
+                nextSectorX = 0;
+                ++nextSectorY;
+            }
+            if (nextSectorY >= this.sectorsY) {
+                nextSectorY = 0;
+                nextSectorX = 0;
+            }
+            let sector: Sector | undefined = this.getSector(nextSectorX, nextSectorY);
+            if (sector) {
+                sector.sectorVisibilityLastCheckTick = currentGameTick;
+                let sp = sector.sectorStartPoint;
+                let ep = {
+                    x: sector.sectorStartPoint.x + SECTOR_SIZE,
+                    y: sector.sectorStartPoint.y + SECTOR_SIZE,
+                };
+                let visibility = calculateAreaVisibility(mapApi, playerData, sp, ep);
+                if (visibility.validTiles > 0) {
+                    sector.sectorVisibilityPct = visibility.visibleTiles / visibility.validTiles;
+                } else {
+                    sector.sectorVisibilityPct = undefined;
+                }
+            }
+            this.lastUpdatedSectorX = nextSectorX;
+            this.lastUpdatedSectorY = nextSectorY;
+            ++nextSectorX;
+            ++updatedThisCycle;
+        }
+    }
+
+    // Return % of sectors that are updated.
+    public getSectorUpdateRatio(sectorsUpdatedSinceGameTick: number): number {
+        let updated = 0,
+            total = 0;
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                let sector: Sector = this.sectors[xx][yy];
+                if (
+                    sector &&
+                    sector.sectorVisibilityLastCheckTick &&
+                    sector.sectorVisibilityLastCheckTick >= sectorsUpdatedSinceGameTick
+                ) {
+                    ++updated;
+                }
+                ++total;
+            }
+        }
+        return updated / total;
+    }
+
+    /**
+     * Return the ratio (0-1) of tiles that are visible. Returns undefined if we haven't scanned the whole map yet.
+     */
+    public getOverallVisibility(): number | undefined {
+        let visible = 0,
+            total = 0;
+        for (let xx = 0; xx < this.sectorsX; ++xx) {
+            for (let yy = 0; yy < this.sectorsY; ++yy) {
+                let sector: Sector = this.sectors[xx][yy];
+
+                // Undefined visibility.
+                if (sector.sectorVisibilityPct != undefined) {
+                    visible += sector.sectorVisibilityPct;
+                    total += 1.0;
+                }
+            }
+        }
+        return visible / total;
+    }
+
+    public getSector(sectorX: number, sectorY: number): Sector | undefined {
+        if (sectorX < 0 || sectorX >= this.sectorsX || sectorY < 0 || sectorY >= this.sectorsY) {
+            return undefined;
+        }
+        return this.sectors[sectorX][sectorY];
+    }
+
+    public getSectorForWorldPosition(x: number, y: number): Sector | undefined {
+        if (x < 0 || x >= this.mapBounds.x || y < 0 || y >= this.mapBounds.y) {
+            return undefined;
+        }
+        return this.sectors[Math.floor(x / SECTOR_SIZE)][Math.floor(y / SECTOR_SIZE)];
+    }
+}

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

@@ -1,47 +1,83 @@
-import { GameApi, PlayerData } from "@chronodivide/game-api";
-import { Squad } from "../squad/squad.js";
-import { SquadBehaviour } from "../squad/squadBehaviour.js";
-import { GlobalThreat } from "../threat/threat.js";
-import { ExpansionMissionFactory } from "./expansionMission.js";
-
-// AI starts Missions based on heuristics, which have one or more squads.
-// Missions can create squads (but squads will disband themselves).
-export interface Mission {
-    onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat | undefined): MissionAction;
-
-    isActive(): boolean;
-
-    removeSquad(squad: Squad): void;
-
-    addSquad(squad: Squad): void;
-
-    getSquads(): Squad[];
-
-    getUniqueName(): string;
-}
-
-export type MissionActionNoop = {
-    type: "noop";
-};
-export type MissionActionCreateSquad = {
-    type: "createSquad";
-    name: string;
-    behaviour: SquadBehaviour;
-};
-export type MissionActionDisband = {
-    type: "disband";
-};
-
-export type MissionAction = MissionActionNoop | MissionActionCreateSquad | MissionActionDisband;
-
-export interface MissionFactory {
-    // Potentially return a new mission.
-    maybeCreateMission(
-        gameApi: GameApi,
-        playerData: PlayerData,
-        threatData: GlobalThreat,
-        existingMissions: Mission[],
-    ): Mission | undefined;
-}
-
-export const missionFactories = [new ExpansionMissionFactory()];
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { Squad } from "../squad/squad.js";
+import { GlobalThreat } from "../threat/threat.js";
+import { MatchAwareness } from "../awareness.js";
+
+// AI starts Missions based on heuristics, which have one or more squads.
+// Missions can create squads (but squads will disband themselves).
+export abstract class Mission<FailureReasons = undefined> {
+    private squad: Squad | null = null;
+    private active = true;
+
+    private onFinish: (reason: FailureReasons, squad: Squad | null) => void = () => {};
+
+    constructor(private uniqueName: string, private priority: number = 1) {}
+
+    abstract onAiUpdate(gameApi: GameApi, playerData: PlayerData, matchAwareness: MatchAwareness): MissionAction;
+
+    isActive(): boolean {
+        return this.active;
+    }
+
+    protected setSquad(squad: Squad): MissionActionRegisterSquad {
+        this.squad = squad;
+        return registerSquad(squad);
+    }
+
+    getSquad(): Squad | null {
+        return this.squad;
+    }
+
+    removeSquad() {
+        // The squad was removed from this mission.
+        this.squad = null;
+    }
+
+    getUniqueName(): string {
+        return this.uniqueName;
+    }
+
+    // Don't call this from the mission itself
+    endMission(reason: FailureReasons): void {
+        this.onFinish(reason, this.squad);
+        this.squad = null;
+        this.active = false;
+    }
+
+    /**
+     * Declare a callback that is executed when the mission is disbanded for whatever reason.
+     */
+    then(onFinish: (reason: FailureReasons, squad: Squad | null) => void): Mission<FailureReasons> {
+        this.onFinish = onFinish;
+        return this;
+    }
+}
+
+export type MissionActionNoop = {
+    type: "noop";
+};
+
+export type MissionActionRegisterSquad = {
+    type: "registerSquad";
+    squad: Squad;
+};
+
+export type MissionActionDisband = {
+    type: "disband";
+    reason: any | null;
+};
+
+export const noop = () =>
+    ({
+        type: "noop",
+    } as MissionActionNoop);
+
+export const registerSquad = (squad: Squad) =>
+    ({
+        type: "registerSquad",
+        squad,
+    } as MissionActionRegisterSquad);
+
+export const disbandMission = (reason?: any) => ({ type: "disband", reason } as MissionActionDisband);
+
+export type MissionAction = MissionActionNoop | MissionActionRegisterSquad | MissionActionDisband;

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

@@ -1,51 +1,103 @@
-// Meta-controller for forming and controlling squads.
-
-import { GameApi, PlayerData } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
-import { Mission, MissionAction, MissionActionDisband, missionFactories } from "./mission.js";
-
-export class MissionController {
-    constructor(private missions: Mission[] = []) {}
-
-    public onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat | undefined) {
-        // Remove disbanded missions.
-        this.missions = this.missions.filter((missions) => missions.isActive());
-
-        let missionActions = this.missions.map((mission) => {
-            return {
-                mission,
-                action: mission.onAiUpdate(gameApi, playerData, threatData),
-            };
-        });
-        // Handle disbands and merges.
-        const isDisband = (a: MissionAction): a is MissionActionDisband => a.type == "disband";
-        let disbandedMissions: Set<string> = new Set();
-        missionActions
-            .filter((a) => isDisband(a.action))
-            .forEach((a) => {
-                a.mission.getSquads().forEach((squad) => {
-                    squad.setMission(undefined);
-                });
-                disbandedMissions.add(a.mission.getUniqueName());
-            });
-        // remove disbanded and merged squads.
-        this.missions.filter((missions) => !disbandedMissions.has(missions.getUniqueName()));
-
-        // Create missions.
-        let newMissions: Mission[];
-        let missionNames: Set<String> = new Set();
-        this.missions.forEach((mission) => missionNames.add(mission.getUniqueName()));
-        missionFactories.forEach((missionFactory) => {
-            let maybeMission = missionFactory.maybeCreateMission(gameApi, playerData, threatData, this.missions);
-            if (maybeMission) {
-                if (missionNames.has(maybeMission.getUniqueName())) {
-                    //console.log(`Rejecting new mission ${maybeMission.getUniqueName()} as another mission exists.`);
-                } else {
-                    console.log(`Starting new mission ${maybeMission.getUniqueName()}.`);
-                    this.missions.push(maybeMission);
-                    missionNames.add(maybeMission.getUniqueName());
-                }
-            }
-        });
-    }
-}
+// Meta-controller for forming and controlling squads.
+
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { GlobalThreat } from "../threat/threat.js";
+import { Mission, MissionAction, MissionActionDisband, MissionActionRegisterSquad } from "./mission.js";
+import { SquadController } from "../squad/squadController.js";
+import { MatchAwareness } from "../awareness.js";
+import { MissionFactory, createMissionFactories } from "./missionFactories.js";
+
+export class MissionController {
+    private missionFactories: MissionFactory[];
+    private missions: Mission<any>[] = [];
+
+    private forceDisbandedMissions: string[] = [];
+
+    constructor(private logger: (message: string) => void) {
+        this.missionFactories = createMissionFactories();
+    }
+
+    public onAiUpdate(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        squadController: SquadController,
+    ) {
+        // Remove inactive missions.
+        this.missions = this.missions.filter((missions) => missions.isActive());
+
+        // Poll missions for requested actions.
+        const missionActions = this.missions.map((mission) => ({
+            mission,
+            action: mission.onAiUpdate(gameApi, playerData, matchAwareness),
+        }));
+
+        // Handle disbands and merges.
+        const isDisband = (a: MissionAction) => a.type == "disband";
+        const disbandedMissions: Map<string, any> = new Map();
+        const disbandedMissionsArray: { mission: Mission; reason: any }[] = [];
+        this.forceDisbandedMissions.forEach((name) => disbandedMissions.set(name, null));
+        this.forceDisbandedMissions = [];
+        missionActions
+            .filter((a) => isDisband(a.action))
+            .forEach((a) => {
+                disbandedMissions.set(a.mission.getUniqueName(), (a.action as MissionActionDisband).reason);
+            });
+
+        // Remove disbanded and merged squads.
+        this.missions
+            .filter((missions) => disbandedMissions.has(missions.getUniqueName()))
+            .forEach((disbandedMission) => {
+                this.logger(`mission disbanded: ${disbandedMission.getUniqueName()}`);
+                const reason = disbandedMissions.get(disbandedMission.getUniqueName());
+                disbandedMissionsArray.push({ mission: disbandedMission, reason });
+                disbandedMission.getSquad()?.setMission(null);
+                disbandedMission.endMission(disbandedMissions.get(disbandedMission.getUniqueName()));
+            });
+        this.missions = this.missions.filter((missions) => !disbandedMissions.has(missions.getUniqueName()));
+
+        // Register new squads
+        const isNewSquad = (a: MissionAction) => a.type == "registerSquad";
+        missionActions
+            .filter((a) => isNewSquad(a.action))
+            .forEach((a) => {
+                const action = a.action as MissionActionRegisterSquad;
+                squadController.registerSquad(action.squad);
+                this.logger(`registered a squad: ${action.squad.getName()}`);
+            });
+
+        // Create dynamic missions.
+        this.missionFactories.forEach((missionFactory) => {
+            missionFactory.maybeCreateMissions(gameApi, playerData, matchAwareness, this);
+            disbandedMissionsArray.forEach(({ reason, mission }) => {
+                missionFactory.onMissionFailed(gameApi, playerData, matchAwareness, mission, reason, this);
+            });
+        });
+    }
+
+    /**
+     * Attempts to add a mission to the active set.
+     * @param mission
+     * @returns The mission if it was accepted, or null if it was not.
+     */
+    public addMission<T>(mission: Mission<T | any>): Mission<T> | null {
+        if (this.missions.some((m) => m.getUniqueName() === mission.getUniqueName())) {
+            // reject non-unique mission names
+            return null;
+        }
+        this.logger(`Added mission: ${mission.getUniqueName()}`);
+        this.missions.push(mission);
+        return mission;
+    }
+
+    /**
+     * Disband the provided mission on the next possible opportunity.
+     */
+    public disbandMission(missionName: string) {
+        this.forceDisbandedMissions.push(missionName);
+    }
+
+    public logDebugOutput() {
+        this.logger(`Missions (${this.missions.length}): ${this.missions.map((m) => m.getUniqueName()).join(", ")}`);
+    }
+}

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

@@ -0,0 +1,46 @@
+import { GameApi, PlayerData } from "@chronodivide/game-api";
+import { ExpansionMissionFactory } from "./missions/expansionMission.js";
+import { Mission } from "./mission.js";
+import { MatchAwareness } from "../awareness.js";
+import { ScoutingMissionFactory } from "./missions/scoutingMission.js";
+import { AttackMissionFactory } from "./missions/attackMission.js";
+import { MissionController } from "./missionController.js";
+import { DefenceMissionFactory } from "./missions/defenceMission.js";
+
+export interface MissionFactory {
+    getName(): string;
+
+    /**
+     * Queries the factory for new missions to be spawned.
+     *
+     * @param gameApi
+     * @param playerData
+     * @param matchAwareness
+     * @param missionController
+     */
+    maybeCreateMissions(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        missionController: MissionController,
+    ): void;
+
+    /**
+     * Called when any mission fails - can be used to trigger another mission in response.
+     */
+    onMissionFailed(
+        gameApi: GameApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+        failedMission: Mission,
+        failureReason: any,
+        missionController: MissionController,
+    ): void;
+}
+
+export const createMissionFactories = () => [
+    new ExpansionMissionFactory(),
+    new ScoutingMissionFactory(),
+    new AttackMissionFactory(),
+    new DefenceMissionFactory(),
+];