kol.js 0.3.0 → 0.4.0

package/src/domains/ClanDungeon.ts

@@ -0,0 +1,230 @@
+import type { Client } from "../Client.js";
+
+export class JoinClanError extends Error {
+  constructor() {
+    super("Could not join clan");
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class RaidLogMissingError extends Error {
+  constructor() {
+    super("Raid log missing");
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export type RaidLogEvent =
+  | {
+      type: "kill";
+      playerName: string;
+      playerId: number;
+      monster: string;
+      count: number;
+      boss: boolean;
+    }
+  | {
+      type: "defeat";
+      playerName: string;
+      playerId: number;
+      monster: string;
+      count: number;
+      boss: boolean;
+    }
+  | {
+      type: "loot";
+      playerName: string;
+      playerId: number;
+      item: string;
+      recipientName: string;
+      recipientId: number;
+    };
+
+export const PLAYER_PREFIX = `([A-Za-z0-9\\-_ ]+)\\s+\\(#(\\d+)\\)\\s+`;
+
+const KILL_MULTI = new RegExp(
+  `^${PLAYER_PREFIX}defeated\\s+(.+?)\\s+x\\s+(\\d+)`,
+  "i",
+);
+const KILL_SINGLE = new RegExp(
+  `^${PLAYER_PREFIX}defeated\\s+(.+?)\\s+\\(1 turn\\)`,
+  "i",
+);
+const DEFEAT_MULTI = new RegExp(
+  `^${PLAYER_PREFIX}was defeated by\\s+(.+?)\\s+x\\s+(\\d+)`,
+  "i",
+);
+const DEFEAT_SINGLE = new RegExp(
+  `^${PLAYER_PREFIX}was defeated by\\s+(.+?)\\s+\\(1 turn\\)`,
+  "i",
+);
+const LOOT = new RegExp(
+  `^${PLAYER_PREFIX}distributed\\s+(.+?)\\s+to\\s+(.+?)\\s+\\(#(\\d+)\\)`,
+  "i",
+);
+
+function matchKill(line: string, bossNames: string[]): RaidLogEvent | null {
+  const multi = line.match(KILL_MULTI);
+  if (multi) {
+    const monster = multi[3].trim();
+    return {
+      type: "kill",
+      playerName: multi[1].trim(),
+      playerId: parseInt(multi[2]),
+      monster,
+      count: parseInt(multi[4]),
+      boss: bossNames.some((b) =>
+        monster.toLowerCase().includes(b.toLowerCase()),
+      ),
+    };
+  }
+
+  const single = line.match(KILL_SINGLE);
+  if (single) {
+    const monster = single[3].trim();
+    return {
+      type: "kill",
+      playerName: single[1].trim(),
+      playerId: parseInt(single[2]),
+      monster,
+      count: 1,
+      boss: bossNames.some((b) =>
+        monster.toLowerCase().includes(b.toLowerCase()),
+      ),
+    };
+  }
+
+  return null;
+}
+
+function matchDefeat(line: string, bossNames: string[]): RaidLogEvent | null {
+  const multi = line.match(DEFEAT_MULTI);
+  if (multi) {
+    const monster = multi[3].trim();
+    return {
+      type: "defeat",
+      playerName: multi[1].trim(),
+      playerId: parseInt(multi[2]),
+      monster,
+      count: parseInt(multi[4]),
+      boss: bossNames.some((b) =>
+        monster.toLowerCase().includes(b.toLowerCase()),
+      ),
+    };
+  }
+
+  const single = line.match(DEFEAT_SINGLE);
+  if (single) {
+    const monster = single[3].trim();
+    return {
+      type: "defeat",
+      playerName: single[1].trim(),
+      playerId: parseInt(single[2]),
+      monster,
+      count: 1,
+      boss: bossNames.some((b) =>
+        monster.toLowerCase().includes(b.toLowerCase()),
+      ),
+    };
+  }
+
+  return null;
+}
+
+function matchLoot(line: string): RaidLogEvent | null {
+  const match = line.match(LOOT);
+  if (!match) return null;
+  return {
+    type: "loot",
+    playerName: match[1].trim(),
+    playerId: parseInt(match[2]),
+    item: match[3].trim(),
+    recipientName: match[4].trim(),
+    recipientId: parseInt(match[5]),
+  };
+}
+
+/**
+ * Try to parse a single stripped log line into a base raid log event.
+ * Returns null if the line doesn't match any known pattern.
+ */
+export function parseLine(
+  line: string,
+  bossNames: string[],
+): RaidLogEvent | null {
+  return (
+    matchKill(line, bossNames) ??
+    matchDefeat(line, bossNames) ??
+    matchLoot(line)
+  );
+}
+
+/**
+ * Service class for interacting with KoL clan dungeons.
+ * Handles joining clans, fetching raid logs, and creating
+ * raid instances from the fetched HTML.
+ */
+export class ClanDungeon {
+  #client: Client;
+
+  constructor(client: Client) {
+    this.#client = client;
+  }
+
+  async getCurrentRaid(clanId: number): Promise<string> {
+    return await this.#client.actionMutex.runExclusive(async () => {
+      if (!(await this.#client.joinClan(clanId))) throw new JoinClanError();
+      const log = await this.#client.fetchText("clan_raidlogs.php");
+      if (!log) throw new RaidLogMissingError();
+      return log;
+    });
+  }
+
+  async getRaidById(clanId: number, raidId: number): Promise<string> {
+    return await this.#client.actionMutex.runExclusive(async () => {
+      if (!(await this.#client.joinClan(clanId))) throw new JoinClanError();
+      return await this.#client.fetchText("clan_viewraidlog.php", {
+        query: {
+          viewlog: raidId,
+          backstart: 0,
+        },
+      });
+    });
+  }
+
+  async getRaidIds(clanId: number, exclude: number[] = []): Promise<number[]> {
+    return await this.#client.actionMutex.runExclusive(async () => {
+      if (!(await this.#client.joinClan(clanId))) throw new JoinClanError();
+      let raidLogs = await this.#client.fetchText("clan_oldraidlogs.php");
+      const raidIds: number[] = [];
+      let row = 0;
+      let done = false;
+      while (
+        !raidLogs.includes("No previous Clan Dungeon records found") &&
+        !done
+      ) {
+        const matches =
+          raidLogs.match(
+            /kisses<\/td><td class=tiny>\[<a href="clan_viewraidlog\.php\?viewlog=(?<id>\d+)/g,
+          ) || [];
+        for (const id of matches) {
+          const cleanId = Number(id.replace(/\D/g, ""));
+          if (exclude.includes(cleanId)) {
+            done = true;
+            break;
+          }
+          raidIds.push(cleanId);
+        }
+        if (!done) {
+          row += 10;
+          raidLogs = await this.#client.fetchText("clan_oldraidlogs.php", {
+            query: {
+              startrow: row,
+            },
+          });
+        }
+      }
+      return raidIds;
+    });
+  }
+}

package/src/domains/Dreadsylvania.test.ts

@@ -0,0 +1,424 @@
+import { describe, expect, test } from "vitest";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { loadFixture } from "../testUtils.js";
+import { DreadsylvaniaRaid, type DreadEvent } from "./Dreadsylvania.js";
+
+function loadDreadFixture(name: string): string {
+  return readFileSync(
+    join(import.meta.dirname, "__fixtures__", "dread", name),
+    "utf8",
+  );
+}
+
+function dread(name: string): DreadsylvaniaRaid {
+  return new DreadsylvaniaRaid(loadDreadFixture(name));
+}
+
+describe("overview", () => {
+  describe("remaining monsters", () => {
+    test("in-progress dungeon", () => {
+      const overview = dread("cdr1-current.html").getOverview();
+      expect(overview.forest.remaining).toBe(493);
+      expect(overview.village.remaining).toBe(509);
+      expect(overview.castle.remaining).toBe(661);
+    });
+
+    test("completed dungeon has 0 remaining", () => {
+      const overview = dread("raid-218519.html").getOverview();
+      expect(overview.forest.remaining).toBe(0);
+      expect(overview.village.remaining).toBe(0);
+      expect(overview.castle.remaining).toBe(0);
+    });
+
+    test("zone with no kills has 1000 remaining", async () => {
+      const log = await loadFixture(import.meta.dirname, "raidlog.html");
+      expect(new DreadsylvaniaRaid(log).getOverview().village.remaining).toBe(
+        1000,
+      );
+    });
+  });
+
+  describe("capacitor", () => {
+    test("detects fixed capacitor", () => {
+      expect(dread("cdr1-current.html").getOverview().capacitor).toBe(true);
+    });
+
+    test.skip("false when not fixed", () => {
+      // Needs a fixture with no fixed capacitor (none of ours have this)
+      expect(
+        new DreadsylvaniaRaid(
+          loadDreadFixture("no-capacitor.html"),
+        ).getOverview().capacitor,
+      ).toBe(false);
+    });
+  });
+
+  describe("skills", () => {
+    test("3 remaining when none used", () => {
+      expect(dread("cdr1-current.html").getOverview().remainingSkills).toBe(3);
+    });
+
+    test("0 remaining when all 3 used", () => {
+      expect(dread("raid-218286.html").getOverview().remainingSkills).toBe(0);
+    });
+
+    test("partial usage", async () => {
+      const log = await loadFixture(import.meta.dirname, "raidlog.html");
+      expect(new DreadsylvaniaRaid(log).getOverview().remainingSkills).toBe(2);
+    });
+  });
+});
+
+describe("boss detection", () => {
+  test("no bosses defeated in active dungeon", () => {
+    const overview = dread("cdr1-current.html").getOverview();
+    expect(overview.forest.boss.status).not.toBe("defeated");
+    expect(overview.village.boss.status).not.toBe("defeated");
+    expect(overview.castle.boss.status).not.toBe("defeated");
+  });
+
+  test("detects Falls-From-Sky", () => {
+    expect(dread("raid-218519.html").getBossStatus("forest")).toMatchObject({
+      name: "Falls-From-Sky",
+      status: "defeated",
+    });
+  });
+
+  test("detects The Great Wolf of the Air", () => {
+    expect(dread("raid-218286.html").getBossStatus("forest")).toMatchObject({
+      name: "The Great Wolf of the Air",
+      status: "defeated",
+    });
+  });
+
+  test("detects The Zombie Homeowners' Association", () => {
+    expect(dread("raid-218519.html").getBossStatus("village")).toMatchObject({
+      name: "The Zombie Homeowners' Association",
+      status: "defeated",
+    });
+  });
+
+  test("detects Count Drunkula", () => {
+    expect(dread("raid-218519.html").getBossStatus("castle")).toMatchObject({
+      name: "Count Drunkula",
+      status: "defeated",
+    });
+  });
+
+  test("detects The Unkillable Skeleton", () => {
+    expect(dread("raid-218286.html").getBossStatus("castle")).toMatchObject({
+      name: "The Unkillable Skeleton",
+      status: "defeated",
+    });
+  });
+
+  test("defeated bosses have confidence 1", () => {
+    expect(dread("raid-218519.html").getBossStatus("forest").confidence).toBe(
+      1,
+    );
+  });
+
+  test("predicts boss from kill differential", async () => {
+    const log = await loadFixture(import.meta.dirname, "raidlog.html");
+    const boss = new DreadsylvaniaRaid(log).getBossStatus("castle");
+    expect(boss).toMatchObject({
+      name: "The Unkillable Skeleton",
+      status: "predicted",
+    });
+    expect(boss.confidence).toBeGreaterThan(0.5);
+  });
+
+  test("detects Mayor Ghost", () => {
+    expect(dread("raid-217988.html").getBossStatus("village")).toMatchObject({
+      name: "Mayor Ghost",
+      status: "defeated",
+    });
+  });
+
+  test("low-confidence prediction with few balanced kills", async () => {
+    const log = await loadFixture(import.meta.dirname, "raidlog.html");
+    const boss = new DreadsylvaniaRaid(log).getBossStatus("forest");
+    expect(boss.status).toBe("predicted");
+    expect(boss.confidence).toBeGreaterThan(0.5);
+    expect(boss.confidence).toBeLessThan(0.9);
+  });
+});
+
+describe("forest details", () => {
+  test("attic", () =>
+    expect(dread("raid-218286.html").getForestStatus().attic).toBe(true));
+  test("watchtower", () =>
+    expect(dread("raid-217988.html").getForestStatus().watchtower).toBe(true));
+  test("auditor badge", () =>
+    expect(dread("raid-218029.html").getForestStatus().auditor).toBe(true));
+  test("music box", () =>
+    expect(dread("raid-218286.html").getForestStatus().musicbox).toBe(true));
+  test("kiwi via 'knocked some fruit loose'", () =>
+    expect(dread("raid-218029.html").getForestStatus().kiwi).toBe(true));
+  test("kiwi via 'wasted some fruit'", () =>
+    expect(dread("raid-213013.html").getForestStatus().kiwi).toBe(true));
+  test("moon-amber", () =>
+    expect(dread("raid-218286.html").getForestStatus().amber).toBe(true));
+
+  test("nothing unlocked", () => {
+    expect(dread("cdr1-current.html").getForestStatus()).toEqual({
+      attic: false,
+      watchtower: false,
+      auditor: false,
+      musicbox: false,
+      kiwi: false,
+      amber: false,
+    });
+  });
+
+  test("everything unlocked", () => {
+    expect(dread("raid-217988.html").getForestStatus()).toEqual({
+      attic: true,
+      watchtower: true,
+      auditor: true,
+      musicbox: true,
+      kiwi: true,
+      amber: true,
+    });
+  });
+});
+
+describe("village details", () => {
+  test("schoolhouse", () =>
+    expect(dread("cdr1-current.html").getVillageStatus().schoolhouse).toBe(
+      true,
+    ));
+  test("master suite", () =>
+    expect(dread("raid-218519.html").getVillageStatus().suite).toBe(true));
+  test("hanging via 'hung'", () =>
+    expect(dread("raid-218205.html").getVillageStatus().hanging).toBe(true));
+
+  test("only schoolhouse unlocked", () => {
+    expect(dread("cdr2-current.html").getVillageStatus()).toEqual({
+      schoolhouse: true,
+      suite: false,
+      hanging: false,
+    });
+  });
+
+  test("everything unlocked", () => {
+    expect(dread("raid-217988.html").getVillageStatus()).toEqual({
+      schoolhouse: true,
+      suite: true,
+      hanging: true,
+    });
+  });
+});
+
+describe("castle details", () => {
+  test("lab", () =>
+    expect(dread("cdr1-current.html").getCastleStatus().lab).toBe(true));
+  test("roast beast", () =>
+    expect(dread("raid-218286.html").getCastleStatus().roast).toBe(true));
+  test("wax banana", () =>
+    expect(dread("raid-218286.html").getCastleStatus().banana).toBe(true));
+  test("stinking agaricus", () =>
+    expect(dread("raid-218029.html").getCastleStatus().agaricus).toBe(true));
+
+  test("nothing unlocked except lab", () => {
+    expect(dread("cdr1-current.html").getCastleStatus()).toEqual({
+      lab: true,
+      roast: false,
+      banana: false,
+      agaricus: false,
+    });
+  });
+
+  test("everything unlocked", () => {
+    expect(dread("raid-217988.html").getCastleStatus()).toEqual({
+      lab: true,
+      roast: true,
+      banana: true,
+      agaricus: true,
+    });
+  });
+});
+
+describe("participation", () => {
+  test("parses kills per player", async () => {
+    const log = await loadFixture(import.meta.dirname, "raidlog.html");
+    expect(
+      new DreadsylvaniaRaid(log).getParticipation()[2802400],
+    ).toHaveProperty("kills", 423);
+  });
+
+  test("parses skill uses", async () => {
+    const log = await loadFixture(import.meta.dirname, "raidlog.html");
+    expect(
+      new DreadsylvaniaRaid(log).getParticipation()[3137318],
+    ).toHaveProperty("skills", 1);
+  });
+
+  test("player with only skill use has 0 kills", async () => {
+    const log = await loadFixture(import.meta.dirname, "raidlog.html");
+    expect(
+      new DreadsylvaniaRaid(log).getParticipation()[3137318],
+    ).toHaveProperty("kills", 0);
+  });
+
+  test("counts single kills, multi-kills, and boss kills", () => {
+    const totalKills = Object.values(
+      dread("raid-218518.html").getParticipation(),
+    ).reduce((sum, { kills }) => sum + kills, 0);
+    expect(totalKills).toBe(3003);
+  });
+
+  test("only counts Dread kills from combined page", async () => {
+    const log = await loadFixture(import.meta.dirname, "raidlog.html");
+    const totalKills = Object.values(
+      new DreadsylvaniaRaid(log).getParticipation(),
+    ).reduce((sum, { kills }) => sum + kills, 0);
+    expect(totalKills).toBe(511);
+  });
+
+  test("returns empty for non-Dread log", () => {
+    expect(
+      Object.keys(
+        new DreadsylvaniaRaid("<html>Not a raid</html>").getParticipation(),
+      ),
+    ).toHaveLength(0);
+  });
+
+  test("mergeParticipation accumulates same player across sources", () => {
+    const merged = DreadsylvaniaRaid.mergeParticipation(
+      { 123: { playerId: 123, kills: 10, skills: 0 } },
+      { 123: { playerId: 123, kills: 5, skills: 1 } },
+    );
+    expect(merged[123]).toEqual({ playerId: 123, kills: 15, skills: 1 });
+  });
+});
+
+describe("predictBoss", () => {
+  const MONSTERS = ["bugbear", "werewolf"] as const;
+  function kills(monster: 0 | 1, count: number): DreadEvent {
+    return {
+      type: "kill",
+      playerName: "Test",
+      playerId: 1,
+      monster: MONSTERS[monster],
+      count,
+      boss: false,
+    };
+  }
+  function banish(monster: 0 | 1): DreadEvent {
+    return {
+      type: "banish",
+      playerName: "Test",
+      playerId: 1,
+      monster: MONSTERS[monster],
+    };
+  }
+  function predict(events: DreadEvent[]) {
+    const raid = new DreadsylvaniaRaid("");
+    (raid as { events: DreadEvent[] }).events = events;
+    return raid.predictBoss("forest");
+  }
+
+  test("no information gives 50/50 confidence", () => {
+    expect(predict([]).confidence).toBeCloseTo(0.5);
+  });
+
+  test("one banish on m1 predicts m2 boss", () => {
+    const p = predict([banish(0)]);
+    expect(p.boss).toBe("werewolf");
+    expect(p.confidence).toBeGreaterThan(0.5);
+  });
+
+  test("two banishes on m1 strongly predicts m2 boss", () => {
+    const p = predict([banish(0), banish(0)]);
+    expect(p.boss).toBe("werewolf");
+    expect(p.confidence).toBeCloseTo(1.0);
+  });
+
+  test("equal banishes on both types gives 50/50", () => {
+    expect(predict([banish(0), banish(1)]).confidence).toBeCloseTo(0.5);
+  });
+
+  test("kill ratio provides evidence with no banishes", () => {
+    const p = predict([kills(0, 300), kills(1, 200)]);
+    expect(p.boss).toBe("bugbear");
+    expect(p.confidence).toBeGreaterThan(0.5);
+  });
+
+  test("more kills increase confidence", () => {
+    const few = predict([kills(0, 6), kills(1, 4)]);
+    const many = predict([kills(0, 600), kills(1, 400)]);
+    expect(few.boss).toBe(many.boss);
+    expect(many.confidence).toBeGreaterThan(few.confidence);
+  });
+
+  test("banish and kills reinforce each other", () => {
+    const banishOnly = predict([banish(0)]);
+    const both = predict([kills(0, 100), banish(0), kills(1, 200)]);
+    expect(banishOnly.boss).toBe("werewolf");
+    expect(both.boss).toBe("werewolf");
+    expect(both.confidence).toBeGreaterThan(banishOnly.confidence);
+  });
+
+  test("kills after a banish equalises ratio are less informative", () => {
+    expect(
+      predict([banish(0), kills(0, 50), kills(1, 50)]).confidence,
+    ).toBeLessThan(0.75);
+  });
+
+  test("kills before banish use pre-banish ratio", () => {
+    expect(predict([kills(0, 300), kills(1, 200), banish(0)]).boss).toBe(
+      "bugbear",
+    );
+  });
+
+  test("works for village zone", () => {
+    const raid = new DreadsylvaniaRaid("");
+    (raid as { events: DreadEvent[] }).events = [
+      { type: "banish", playerName: "Test", playerId: 1, monster: "ghost" },
+    ];
+    const p = raid.predictBoss("village");
+    expect(p.boss).toBe("zombie");
+    expect(p.confidence).toBeGreaterThan(0.5);
+  });
+
+  test("works for castle zone", () => {
+    const raid = new DreadsylvaniaRaid("");
+    (raid as { events: DreadEvent[] }).events = [
+      {
+        type: "kill",
+        playerName: "Test",
+        playerId: 1,
+        monster: "vampire",
+        count: 100,
+        boss: false,
+      },
+      {
+        type: "kill",
+        playerName: "Test",
+        playerId: 1,
+        monster: "skeleton",
+        count: 300,
+        boss: false,
+      },
+    ];
+    const p = raid.predictBoss("castle");
+    expect(p.boss).toBe("skeleton");
+    expect(p.confidence).toBeGreaterThan(0.5);
+  });
+
+  test("defeat by boss gives confidence 1", () => {
+    const defeat: DreadEvent = {
+      type: "defeat",
+      playerName: "Test",
+      playerId: 1,
+      monster: "The Great Wolf of the Air",
+      count: 1,
+      boss: true,
+    };
+    const p = predict([kills(0, 50), kills(1, 50), defeat]);
+    expect(p.boss).toBe("werewolf");
+    expect(p.confidence).toBe(1);
+  });
+});