src/mlpccg/draft/bot.ts

@@ -5,7 +5,6 @@ export class DraftBot {
   assign(player: SessionPlayer) {
     player.on("available-picks", cards => {
       const pick = this.pick(cards);
-      // setTimeout hack to avoid handlers being called before the rest of the code
       setTimeout(() => player.pick(pick.ID), 0);
     });
   }

src/mlpccg/draft/cube.ts

@@ -40,9 +40,7 @@ export class Cube {
   }
 
   static async fromURL(url: string) {
-    const res = await axios(url, {
-      responseType: "text"
-    });
+    const res = await axios(url);
     return await this.fromList(res.data);
   }
 }

src/mlpccg/draft/i8pcube.ts

@@ -1,81 +0,0 @@
-import { Card, cardFromIDs } from "@/mlpccg";
-import {
-  PackSchema,
-  I8PCubeSchema,
-  I8PPackSchema,
-  I8PFileSchema,
-  DraftSchema
-} from "./types";
-import axios from "axios";
-import { PackBuilder } from "./booster";
-
-export class I8PCube {
-  private pools: Record<string, Card[]>;
-  private packschema: I8PPackSchema[];
-  private problemCount: number;
-
-  constructor(cubefile: I8PCubeSchema) {
-    this.pools = cubefile.Cards;
-    this.packschema = cubefile.Schema;
-    this.problemCount = cubefile.ProblemPackSize;
-  }
-
-  schema(): DraftSchema {
-    return {
-      boosters: {
-        main: 4,
-        problem: 1
-      },
-      factories: {
-        main: new PackBuilder({
-          slots: this.packschema.map(s => ({
-            amount: s.Amount,
-            provider: this.provider(s.Type),
-            alternate: []
-          }))
-        }),
-        problem: new PackBuilder({
-          slots: [
-            {
-              amount: this.problemCount,
-              provider: this.provider("problem"),
-              alternate: []
-            }
-          ]
-        })
-      }
-    };
-  }
-
-  *provider(name: string | "all") {
-    let poolname = name;
-    while (true) {
-      if (name == "all") {
-        const pools = Object.keys(this.pools);
-        const idx = Math.floor(Math.random() * pools.length);
-        poolname = pools[idx];
-      }
-      const pool = this.pools[poolname];
-      if (pool.length <= 0) {
-        return;
-      }
-      const idx = Math.floor(Math.random() * pool.length);
-      const card = pool.splice(idx, 1);
-      yield card[0];
-    }
-  }
-
-  static async fromURL(url: string) {
-    const res = await axios(url);
-    const cubefile = res.data as I8PFileSchema;
-    let cards: Record<string, Card[]> = {};
-    for (const pool in cubefile.Cards) {
-      cards[pool] = await cardFromIDs(cubefile.Cards[pool]);
-    }
-    return new this({
-      Cards: cards,
-      ProblemPackSize: cubefile.ProblemPackSize,
-      Schema: cubefile.Schema
-    });
-  }
-}

src/mlpccg/draft/session.ts

@@ -4,7 +4,6 @@ import { Card } from "@/mlpccg";
 import { Pack, Direction } from "./types";
 import { DraftProvider } from "./provider";
 import { DraftBot } from "./bot";
-import { I8PCube } from "./i8pcube";
 
 export class Session extends EventEmitter {
   private options: DraftOptions;
@@ -180,9 +179,7 @@ export class Session extends EventEmitter {
         return new Session(options, provider);
       }
       case "i8pcube":
-        const cube = await I8PCube.fromURL(options.url);
-        const provider = new DraftProvider(cube.schema());
-        return new Session(options, provider);
+        throw new Error("not implemented");
       default:
         throw new Error("Unknown draft source");
     }

src/mlpccg/draft/types.ts

@@ -71,20 +71,3 @@ export interface DraftSchema {
 }
 
 export type Direction = "cw" | "ccw";
-
-export interface I8PCubeSchema {
-  Schema: I8PPackSchema[];
-  ProblemPackSize: number;
-  Cards: Record<string, Card[]>;
-}
-
-export interface I8PFileSchema {
-  Schema: I8PPackSchema[];
-  ProblemPackSize: number;
-  Cards: Record<string, string[]>;
-}
-
-export interface I8PPackSchema {
-  Amount: number;
-  Type: string;
-}

src/tests/unit/draft.spec.ts

@@ -1,5 +1,5 @@
 import { setupIDBShim, EventHook } from "@/testing";
-import { initDB, loadSets, Database, Card } from "@/mlpccg";
+import { initDB, loadSets, Database } from "@/mlpccg";
 import {
   PackBuilder,
   spanByRarity,
@@ -94,38 +94,4 @@ describe("mlpccg/draft", () => {
     }
     await hook.expect("session-done");
   });
-
-  test("Sessions can load and draft I8PCube files", async () => {
-    expect(Database).toBeTruthy();
-    const session = await Session.create({
-      type: "booster-draft",
-      source: "i8pcube",
-      url: "https://mcg.zyg.ovh/cubes/hamchacube.json",
-      packs: 4,
-      players: 4,
-      spacing: "evenly"
-    });
-    const hook = new EventHook();
-    hook.hookEmitter(session, "start", "session-start");
-    session.assign(["test1"], (_, player) => {
-      hook.hookEmitter(player, "available-picks", "got-cards");
-    });
-    session.start();
-    await hook.expect("session-start");
-    await hook.expect("got-cards", 1000, (cards: Card[]) => {
-      expect(cards).toHaveLength(12);
-      // Check for 2 or more multicolor cards
-      const multicolor = cards.filter(
-        c =>
-          c.Element.length > 1 ||
-          (c.Requirement && Object.keys(c.Requirement).length > 1)
-      );
-      expect(multicolor.length).toBeGreaterThanOrEqual(2);
-      // Check for 2 or more entry cards
-      const entry = cards.filter(
-        c => !c.Requirement || c.Requirement.length < 1
-      );
-      expect(entry.length).toBeGreaterThanOrEqual(2);
-    });
-  });
 });