@supalosa/chronodivide-bot 0.1.1 → 0.2.0

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

@@ -0,0 +1,56 @@
+import { ActionsApi, GameApi, OrderType, PlayerData, Point2D, SideType } from "@chronodivide/game-api";
+import { GlobalThreat } from "../../threat/threat.js";
+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";
+
+const SCOUT_MOVE_COOLDOWN_TICKS = 30;
+
+export class ScoutingSquad implements SquadBehaviour {
+    private scoutingWith: {
+        unitId: number;
+        gameTick: number;
+    } | null = null;
+
+    public onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        squad: Squad,
+        matchAwareness: MatchAwareness,
+    ): SquadAction {
+        const scoutNames = ["ADOG", "DOG", "E1", "E2", "FV", "HTK"];
+        const scouts = squad.getUnitsOfTypes(gameApi, ...scoutNames);
+
+        if ((matchAwareness.getSectorCache().getOverallVisibility() || 0) > 0.9) {
+            return disband();
+        }
+
+        if (scouts.length === 0) {
+            this.scoutingWith = null;
+            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);
+                    }
+                }
+            });
+
+            // Add a cooldown to scout attempts.
+            this.scoutingWith = {
+                unitId: scouts[0].id,
+                gameTick: gameApi.getCurrentTick(),
+            };
+        }
+        return noop();
+    }
+}

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

@@ -1,97 +1,163 @@
-import { GameApi, PlayerData, TechnoRules, UnitData } from "@chronodivide/game-api";
-import { Mission } from "../mission/mission.js";
-import { GlobalThreat } from "../threat/threat.js";
-import { SquadAction, SquadBehaviour } from "./squadBehaviour.js";
-
-export enum SquadLiveness {
-    SquadDead,
-    SquadActive,
-}
-
-export type SquadConstructionRequest = {
-    squad: Squad;
-    unitType: TechnoRules;
-    priority: number;
-    // quantity: number
-};
-
-export class Squad {
-    constructor(
-        private name: string,
-        private behaviour: SquadBehaviour,
-        private mission: Mission | undefined,
-        private unitIds: number[] = [],
-        private liveness: SquadLiveness = SquadLiveness.SquadActive,
-        private lastLivenessUpdateTick: number = 0,
-    ) {}
-
-    public getName(): string {
-        return this.name;
-    }
-
-    public onAiUpdate(gameApi: GameApi, playerData: PlayerData, threatData: GlobalThreat | undefined): SquadAction {
-        this.updateLiveness(gameApi);
-        if (this.mission && this.mission.isActive() == false) {
-            // Orphaned squad, might get picked up later.
-            this.mission.removeSquad(this);
-            this.mission = undefined;
-        }
-        let outcome = this.behaviour.onAiUpdate(gameApi, playerData, this, threatData);
-        return outcome;
-    }
-
-    public getMission(): Mission | undefined {
-        return this.mission;
-    }
-
-    public setMission(mission: Mission | undefined) {
-        if (this.mission != undefined && this.mission != mission) {
-            this.mission.removeSquad(this);
-        }
-        this.mission = mission;
-    }
-
-    public getUnitIds(): number[] {
-        return this.unitIds;
-    }
-
-    public getUnits(gameApi: GameApi): UnitData[] {
-        return this.unitIds
-            .map((unitId) => gameApi.getUnitData(unitId))
-            .filter((unit) => unit != null)
-            .map((unit) => unit!);
-    }
-
-    public getUnitsOfType(gameApi: GameApi, f: (r: UnitData | undefined) => boolean): UnitData[] {
-        return this.unitIds
-            .map((unitId) => gameApi.getUnitData(unitId))
-            .filter(f)
-            .map((unit) => unit!);
-    }
-
-    public removeUnit(unitIdToRemove: number): void {
-        this.unitIds = this.unitIds.filter((unitId) => unitId != unitIdToRemove);
-    }
-
-    public clearUnits(): void {
-        this.unitIds = [];
-    }
-
-    public addUnit(unitIdToAdd: number): void {
-        this.unitIds.push(unitIdToAdd);
-    }
-
-    private updateLiveness(gameApi: GameApi) {
-        this.unitIds = this.unitIds.filter((unitId) => gameApi.getUnitData(unitId));
-        this.lastLivenessUpdateTick = gameApi.getCurrentTick();
-        if (this.unitIds.length == 0) {
-            if (this.liveness == SquadLiveness.SquadActive) {
-                this.liveness = SquadLiveness.SquadDead;
-            }
-        }
-    }
-
-    public getLiveness() {
-        return this.liveness;
-    }
-}
+import { ActionsApi, GameApi, PlayerData, Point2D, TechnoRules, Tile, UnitData } 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";
+
+export enum SquadLiveness {
+    SquadDead,
+    SquadActive,
+}
+
+export type SquadConstructionRequest = {
+    squad: Squad;
+    unitType: TechnoRules;
+    priority: number;
+};
+
+const calculateCenterOfMass: (unitTiles: Tile[]) => {
+    centerOfMass: Point2D;
+    maxDistance: number;
+} | null = (unitTiles) => {
+    if (unitTiles.length === 0) {
+        return null;
+    }
+    // TODO: use median here
+    const sums = unitTiles.reduce(
+        ({ x, y }, tile) => {
+            return {
+                x: x + (tile?.rx || 0),
+                y: y + (tile?.ry || 0),
+            };
+        },
+        { x: 0, y: 0 },
+    );
+    const centerOfMass = {
+        x: Math.round(sums.x / unitTiles.length),
+        y: 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)!;
+    return { centerOfMass, maxDistance };
+};
+
+export class Squad {
+    private unitIds: number[] = [];
+    private liveness: SquadLiveness = SquadLiveness.SquadActive;
+    private lastLivenessUpdateTick: number = 0;
+    private centerOfMass: Point2D | null = null;
+    private maxDistanceToCenterOfMass: number | null = null;
+
+    constructor(
+        private name: string,
+        private behaviour: SquadBehaviour,
+        private mission: Mission<any> | null,
+        private killable = false,
+    ) {}
+
+    public getName(): string {
+        return this.name;
+    }
+
+    public getCenterOfMass() {
+        return this.centerOfMass;
+    }
+
+    public getMaxDistanceToCenterOfMass() {
+        return this.maxDistanceToCenterOfMass;
+    }
+
+    public onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        matchAwareness: MatchAwareness,
+    ): SquadAction {
+        this.updateLiveness(gameApi);
+        const movableUnitTiles = this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => unit?.canMove)
+            .map((unit) => unit?.tile)
+            .filter((tile) => !!tile) as Tile[];
+        const tileMetrics = calculateCenterOfMass(movableUnitTiles);
+        if (tileMetrics) {
+            this.centerOfMass = tileMetrics.centerOfMass;
+            this.maxDistanceToCenterOfMass = tileMetrics.maxDistance;
+        } else {
+            this.centerOfMass = null;
+            this.maxDistanceToCenterOfMass = null;
+        }
+
+        if (this.mission && this.mission.isActive() == false) {
+            // Orphaned squad, might get picked up later.
+            this.mission.removeSquad();
+            this.mission = null;
+            return disband();
+        } else if (!this.mission) {
+            return disband();
+        }
+        let outcome = this.behaviour.onAiUpdate(gameApi, actionsApi, playerData, this, matchAwareness);
+        return outcome;
+    }
+    public getMission(): Mission | null {
+        return this.mission;
+    }
+
+    public setMission(mission: Mission | null) {
+        if (this.mission != undefined && this.mission != mission) {
+            this.mission.removeSquad();
+        }
+        this.mission = mission;
+    }
+
+    public getUnitIds(): number[] {
+        return this.unitIds;
+    }
+
+    public getUnits(gameApi: GameApi): UnitData[] {
+        return this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => unit != null)
+            .map((unit) => unit!);
+    }
+
+    public getUnitsOfTypes(gameApi: GameApi, ...names: string[]): UnitData[] {
+        return this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => !!unit && names.includes(unit.name))
+            .map((unit) => unit!);
+    }
+
+    public getUnitsMatching(gameApi: GameApi, filter: (r: UnitData) => boolean): UnitData[] {
+        return this.unitIds
+            .map((unitId) => gameApi.getUnitData(unitId))
+            .filter((unit) => !!unit && filter(unit))
+            .map((unit) => unit!);
+    }
+
+    public removeUnit(unitIdToRemove: number): void {
+        this.unitIds = this.unitIds.filter((unitId) => unitId != unitIdToRemove);
+    }
+
+    public addUnit(unitIdToAdd: number): void {
+        this.unitIds.push(unitIdToAdd);
+    }
+
+    private updateLiveness(gameApi: GameApi) {
+        this.unitIds = this.unitIds.filter((unitId) => gameApi.getUnitData(unitId));
+        this.lastLivenessUpdateTick = gameApi.getCurrentTick();
+        if (this.killable && this.unitIds.length == 0) {
+            if (this.liveness == SquadLiveness.SquadActive) {
+                this.liveness = SquadLiveness.SquadDead;
+            }
+        }
+    }
+
+    public getLiveness() {
+        return this.liveness;
+    }
+}

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

@@ -1,43 +1,61 @@
-import { GameApi, PlayerData, TechnoRules } from "@chronodivide/game-api";
-import { GlobalThreat } from "../threat/threat.js";
-import { SquadExpansion } from "./behaviours/squadExpansion.js";
-import { Squad } from "./squad.js";
-
-export type SquadActionNoop = {
-    type: "noop";
-};
-export type SquadActionDisband = {
-    type: "disband";
-};
-export type SquadActionMergeInto = {
-    type: "mergeInto";
-    mergeInto: Squad;
-};
-export type SquadActionClaimUnits = {
-    type: "claimUnit";
-    unitIds: number[];
-};
-
-export type SquadAction = SquadActionNoop | SquadActionDisband | SquadActionMergeInto | SquadActionClaimUnits;
-
-export interface SquadBehaviour {
-    onAiUpdate(
-        gameApi: GameApi,
-        playerData: PlayerData,
-        squad: Squad,
-        threatData: GlobalThreat | undefined,
-    ): SquadAction;
-
-    // State the desired composition of the Squad.
-    getDesiredComposition(
-        gameApi: GameApi,
-        playerData: PlayerData,
-        squad: Squad,
-        threatData: GlobalThreat | undefined,
-    ): { unitName: string; priority: number; amount: number }[];
-}
-
-export const allSquadBehaviours: SquadBehaviour[] = [
-    //new SquadScouters(),
-    new SquadExpansion(),
-];
+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";
+
+export type SquadActionNoop = {
+    type: "noop";
+};
+export type SquadActionDisband = {
+    type: "disband";
+};
+export type SquadActionMergeInto = {
+    type: "mergeInto";
+    mergeInto: Squad;
+};
+export type SquadActionRequestUnits = {
+    type: "request";
+    unitNames: string[];
+    priority: number;
+};
+export type SquadActionRequestSpecificUnits = {
+    type: "requestSpecific";
+    unitIds: number[];
+    priority: number;
+};
+export type SquadActionGrabFreeCombatants = {
+    type: "requestCombatants";
+    point: Point2D;
+    radius: number;
+};
+
+export const noop = () => ({ type: "noop" } as SquadActionNoop);
+
+export const disband = () => ({ type: "disband" } as SquadActionDisband);
+
+export const requestUnits = (unitNames: string[], priority: number) =>
+    ({ type: "request", unitNames, priority } as SquadActionRequestUnits);
+
+export const requestSpecificUnits = (unitIds: number[], priority: number) =>
+    ({ type: "requestSpecific", unitIds, priority } as SquadActionRequestSpecificUnits);
+
+export const grabCombatants = (point: Point2D, radius: number) =>
+    ({ type: "requestCombatants", point, radius } as SquadActionGrabFreeCombatants);
+
+export type SquadAction =
+    | SquadActionNoop
+    | SquadActionDisband
+    | SquadActionMergeInto
+    | SquadActionRequestUnits
+    | SquadActionRequestSpecificUnits
+    | SquadActionGrabFreeCombatants;
+
+export interface SquadBehaviour {
+    onAiUpdate(
+        gameApi: GameApi,
+        actionsApi: ActionsApi,
+        playerData: PlayerData,
+        squad: Squad,
+        matchAwareness: MatchAwareness
+    ): SquadAction;
+}

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

@@ -0,0 +1,8 @@
+import { ExpansionSquad } from "./behaviours/expansionSquad.js";
+import { SquadBehaviour } from "./squadBehaviour.js";
+
+/*
+export const ALL_SQUAD_BEHAVIOURS: SquadBehaviour[] = [
+    //new SquadScouters(),
+    new SquadExpansion(),
+];*/