Fix multi card same pack (#976)

Author: HerveH44

.babelrc

@@ -27,6 +27,7 @@
         "@babel/plugin-proposal-function-sent",
         "@babel/plugin-proposal-export-namespace-from",
         "@babel/plugin-proposal-numeric-separator",
-        "@babel/plugin-proposal-throw-expressions"
+        "@babel/plugin-proposal-throw-expressions",
+        "@babel/plugin-proposal-private-methods"
     ]
 }

backend/human.js

@@ -121,7 +121,7 @@ module.exports = class extends Player {
 
     this.pool.push(card);
     this.picks.push(pickcard);
-    this.send("add", card.name);
+    this.send("add", card);
 
     let [next] = this.packs;
     if (!next)

backend/pool.js

@@ -1,6 +1,19 @@
 const {sample, shuffle, random, range, times, constant, pull} = require("lodash");
 const boosterGenerator = require("./boosterGenerator");
 const { getCardByUuid, getCardByName, getRandomSet, getExpansionOrCoreModernSets: getModernList, getExansionOrCoreSets: getSetsList } = require("./data");
+const draftId = require("uuid").v1;
+
+/**
+ * @desc add a unique id to a card
+ * @param card
+ * @returns {{...card, cardId: string}}
+ */
+const addCardId = (card) => ({
+  ...card,
+  cardId: draftId()
+});
+
+const addCardIdsToBoosterCards = (pack) => pack.map(addCardId);
 
 const SealedCube = ({ cubeList, playersLength, playerPoolSize = 90 }) => {
   return DraftCube({
@@ -11,14 +24,12 @@ const SealedCube = ({ cubeList, playersLength, playerPoolSize = 90 }) => {
   });
 };
 
-//TODO: filter cards that are from set EXP etc.
 const DraftCube = ({ cubeList, playersLength, packsNumber = 3, playerPackSize = 15 }) => {
   let list = shuffle(cubeList); // copy the list to work on it
 
   return range(playersLength * packsNumber)
-    .map(() => {
-      return list.splice(0, playerPackSize).map(getCardByName);
-    });
+    .map(() => list.splice(0, playerPackSize).map(getCardByName))
+    .map(addCardIdsToBoosterCards);
 };
 
 // Replace RNG set with real set
@@ -29,12 +40,14 @@ const replaceRNGSet = (sets) => (
 const SealedNormal = ({ playersLength, sets }) => (
   times(playersLength , constant(replaceRNGSet(sets)))
     .map(sets => sets.flatMap(boosterGenerator))
+    .map(addCardIdsToBoosterCards)
 );
 
 const DraftNormal = ({ playersLength, sets }) => (
   replaceRNGSet(sets)
     .flatMap(set => times(playersLength, constant(set)))
     .map(boosterGenerator)
+    .map(addCardIdsToBoosterCards)
 );
 
 // Get a random set and transform it to pack
@@ -79,13 +92,15 @@ const DraftChaos = ({ playersLength, packsNumber = 3, modernOnly, totalChaos })
   const setList = modernOnly ? getModernList() : getSetsList();
 
   return range(playersLength * packsNumber)
-    .map(() => totalChaos ? getTotalChaosPack(setList) : getRandomPack(setList));
+    .map(() => totalChaos ? getTotalChaosPack(setList) : getRandomPack(setList))
+    .map(addCardIdsToBoosterCards);
 };
 
 const SealedChaos = ({ playersLength, packsNumber = 6, modernOnly, totalChaos }) => {
   const pool = DraftChaos({playersLength, packsNumber, modernOnly, totalChaos});
   return range(playersLength)
-    .map(() => pool.splice(0, packsNumber).flat());
+    .map(() => pool.splice(0, packsNumber).flat())
+    .map(addCardIdsToBoosterCards);
 };
 
 module.exports = {

backend/pool.spec.js

@@ -3,67 +3,84 @@
 const assert = require("assert");
 const Pool = require("./pool");
 const {range, times, constant} = require("lodash");
-const { getPlayableSets } = require("./data");
+const {getPlayableSets} = require("./data");
+
+const assertPackIsCorrect = (got) => {
+  const cardIds = new Set();
+  let expectedCardsSize = 0;
+  got.forEach(pool => pool.forEach(card => {
+    assert(card.name !== undefined);
+    assert(card.cardId !== undefined);
+    cardIds.add(card.cardId);
+    expectedCardsSize++;
+  }));
+  assert.equal(cardIds.size, expectedCardsSize, "cards should all have a unique ID");
+};
 
 describe("Acceptance tests for Pool class", () => {
   describe("can make a cube pool", () => {
     it("should return a sealed cube pool with length equal to player length", () => {
       const cubeList = times(720, constant("island"));
       const playersLength = 8;
-      const got = Pool.SealedCube({ cubeList, playersLength });
-      assert.equal(playersLength, got.length);
-      got.forEach(pool => pool.forEach(card => assert(card.name != undefined)));
+      const playerPoolSize = 90;
+      const got = Pool.SealedCube({cubeList, playersLength, playerPoolSize});
+      assert.equal(got.length, playersLength);
+      assertPackIsCorrect(got);
     });
 
     it("should return a draft cube pool with length equal to player length per playersPack", () => {
       const cubeList = times(720, constant("island"));
       const playersLength = 8;
       const packsNumber = 3;
-      const got = Pool.DraftCube({ cubeList, playersLength, packsNumber });
-      assert.equal(playersLength*packsNumber, got.length);
-      got.forEach(pool => pool.forEach(card => assert(card.name != undefined)));
+      const playerPackSize = 15;
+      const got = Pool.DraftCube({cubeList, playersLength, packsNumber, playerPackSize});
+      assert.equal(got.length, playersLength * packsNumber);
+      assertPackIsCorrect(got);
     });
   });
 
   describe("can make a normal pool", () => {
     it("should return a sealed pool with length equal to player length", () => {
-      const sets = times(6, constant("M19"));
+      const packsNumber = 6;
+      const sets = times(packsNumber, constant("M19"));
       const playersLength = 8;
-      const got = Pool.SealedNormal({ sets, playersLength });
-      assert.equal(playersLength, got.length);
-      got.forEach(pool => pool.forEach(card => assert(card.name != undefined)));
+      const got = Pool.SealedNormal({sets, playersLength});
+      assert.equal(got.length, playersLength);
+      assertPackIsCorrect(got);
     });
 
     it("should return a draft pool with length equal to player length per playersPack", () => {
-      const sets = times(3, constant("M19"));
+      const packsNumber = 3;
+      const sets = times(packsNumber, constant("M19"));
       const playersLength = 8;
-      const got = Pool.DraftNormal({ sets, playersLength });
-      assert.equal(playersLength * 3, got.length);
-      got.forEach(pool => pool.forEach(card => assert(card.name != undefined)));
+      const got = Pool.DraftNormal({sets, playersLength});
+      assert.equal(got.length, playersLength * packsNumber);
+      assertPackIsCorrect(got);
     });
   });
 
   describe("can make a chaos pool", () => {
     it("should return a sealed chaos pool with length equal to player length", () => {
       const playersLength = 8;
       const got = Pool.SealedChaos({ modernOnly: true, totalChaos: true, playersLength });
-      assert.equal(playersLength, got.length);
-      got.forEach(pool => pool.forEach(card => assert(card.name != undefined)));
+      assert.equal(got.length, playersLength);
+      assertPackIsCorrect(got);
     });
 
     it("should return a draft chaos pool with length equal to player length per playersPack", () => {
       const playersLength = 8;
-      const got = Pool.DraftChaos({ modernOnly: true, totalChaos: true, playersLength });
-      assert.equal(playersLength * 3, got.length);
-      got.forEach(pool => pool.forEach(card => assert(card.name != undefined)));
+      const packsNumber = 3;
+      const got = Pool.DraftChaos({packsNumber, modernOnly: true, totalChaos: true, playersLength});
+      assert.equal(got.length, playersLength * packsNumber);
+      assertPackIsCorrect(got);
     });
   });
 
   describe("can make a TimeSpiral pool", () => {
     it("should return a timespiral pool", () => {
       const [got] = Pool.DraftNormal({playersLength: 1, sets: ["TSP"]});
       assert.equal(got.length, 15);
-      got.forEach(card => assert(card.name != undefined));
+      assertPackIsCorrect([got]);
     });
   });
 
@@ -75,10 +92,8 @@ describe("Acceptance tests for Pool class", () => {
           if (code === "random" || Date.parse(releaseDate) > new Date() || code === "UST") {
             return;
           }
-          const [got] = Pool.DraftNormal({playersLength: 1, sets: [code]});
-          got.forEach(card => {
-            assert(card.name != undefined, `${code} has an error: ${card}`);
-          });
+          const got = Pool.DraftNormal({playersLength: 1, sets: [code]});
+          assertPackIsCorrect(got);
         });
       });
     });

frontend/src/app.js

@@ -3,6 +3,7 @@ import EventEmitter from "events";
 import {STRINGS} from "./config";
 import eio from "engine.io-client";
 import {times, constant} from "lodash";
+import GameState from "./gamestate";
 
 function message(msg) {
   let args = JSON.parse(msg);
@@ -68,6 +69,8 @@ let App = {
     pickNumber: 0,
     packSize: 15,
     gameSeats: 8, // seats of the game being played
+    gameState: null, // records the current state of cards is a GameState
+    gameStates: {}, // Object representation of the gameState
 
     get didGameStart() {
       // both round === 0 and round is undefined
@@ -133,6 +136,20 @@ let App = {
     let msg = JSON.stringify(args);
     this.ws.send(msg);
   },
+  initGameState(id) {
+    const { gameStates } = App.state;
+    if (!gameStates[id]) {
+      App.state.gameState = new GameState();
+    } else {
+      App.state.gameState = new GameState(gameStates[id]);
+    }
+    App.state.gameState.on("updateGameState", (gameState) => {
+      App.save("gameStates", {
+        // ...App.state.gameStates,
+        [id]: gameState
+      });
+    });
+  },
   error(err) {
     App.err = err;
     App.route("");