distribute bots more equally between players (#1694)

Modifies random bot placement to placement using a distribution algorithm to
achieve more even placement in seats.

Distribution function added to util.js to be independently testable from the
Game class.  Unit tests added.

Co-authored-by: mildmongrel <[email protected]>

Author: mildmongrel

backend/game.js

@@ -11,6 +11,7 @@ const Rooms = require("./rooms");
 const logger = require("./logger");
 const Sock = require("./sock");
 const {saveDraftStats, getDataDir} = require("./data");
+const {distributeArrays} = require("./util");
 
 module.exports = class Game extends Room {
   constructor({ hostId, title, seats, type, sets, cube, isPrivate, modernOnly, totalChaos, chaosPacksNumber, picksPerPack }) {
@@ -556,20 +557,23 @@ module.exports = class Game extends Room {
       Object.assign(this, { addBots, useTimer, timerLength, shufflePlayers });
       this.renew();
 
-      if (this.shouldAddBots()) {
-        while (this.players.length < this.seats) {
-          const burnsPerPack = this.type === "cube draft"
-            ? this.cube.burnsPerPack
-            : 0;
-          this.players.push(new Bot(this.picksPerPack, burnsPerPack, this.id));
-          this.bots++;
-        }
-      }
-
       if (shufflePlayers) {
         this.players = shuffle(this.players);
       }
 
+      if (this.shouldAddBots()) {
+        const burnsPerPack = this.type === "cube draft"
+          ? this.cube.burnsPerPack
+          : 0;
+
+        let bots = [];
+        for (let i = 0; i < (this.seats - this.players.length); i++) {
+          bots.push(new Bot(this.picksPerPack, burnsPerPack, this.id));
+        }
+        this.bots += bots.length;
+        this.players = distributeArrays(this.players, bots);
+      }
+
       this.createPool();
 
       if (/sealed/.test(this.type)) {

backend/util.js

@@ -110,5 +110,30 @@ module.exports = {
     assert(typeof shufflePlayers === "boolean", "shufflePlayers must be a boolean");
     assert(useTimer && ["Fast", "Moderate", "Slow", "Leisurely"].includes(timerLength),
       "timerLength must be Fast, Moderate, Slow or Leisurely");
+  },
+
+  // distributes elements in arr1 and arr2 as evenly as possible using a method
+  // inspired by Bresenham's line algorithm
+  distributeArrays(arr1, arr2) {
+    assert(Array.isArray(arr1), "arr1 must be an array");
+    assert(Array.isArray(arr2), "arr2 must be an array");
+
+    let arrX = (arr1.length >= arr2.length) ? arr1 : arr2;
+    let arrY = (arr1.length >= arr2.length) ? arr2 : arr1;
+    let out = [];
+
+    let diff = (2 * arrY.length) - arrX.length;
+    let y = 0;
+    for (let x = 0; x < arrX.length; x++) {
+      if (diff > 0) {
+        out.push( arrY[y] );
+        y++;
+        diff -= (2 * arrX.length);
+      }
+      out.push( arrX[x] );
+      diff += (2 * arrY.length);
+    }
+
+    return out;
   }
 };

backend/util.spec.js

@@ -0,0 +1,41 @@
+const assert = require("assert");
+const util = require("./util");
+const { describe, it } = require("mocha");
+
+describe("Acceptance tests for util functions", () => {
+  describe("can distribute arrays", () => {
+    it("produces a new array with each element from each argument", () => {
+      // note this also tests degenerate cases with zero-element arrays
+      for (let i = 0; i < 8; i++) {
+        for (let j = 0; j < 8; j++) {
+          const arr1 = Array(i).fill(1); // array of 1's
+          const arr2 = Array(j).fill(2); // array of 2's
+
+          const out = util.distributeArrays( arr1, arr2 );
+          assert.equal(out.length, i + j);
+          assert(out.filter(i => i === 1).length == arr1.length);
+          assert(out.filter(i => i === 2).length == arr2.length);
+
+          const outRev = util.distributeArrays( arr2, arr1 );
+          assert.equal(outRev.length, i + j);
+          assert(outRev.filter(i => i === 1).length == arr1.length);
+          assert(outRev.filter(i => i === 2).length == arr2.length);
+        }
+      }
+    });
+    it("evenly distributes arrays with the same number of elements", () => {
+      const arr1 = [0, 1, 2, 3];
+      const arr2 = [10, 11, 12, 13];
+      const out = util.distributeArrays( arr1, arr2 );
+      assert.equal(out.length, 8);
+
+      // check that distance between arr1 elements is always even
+      const firstIdx1 = out.indexOf(arr1[0]);
+      for (let i = 0; i < arr1.length; ++i) {
+        let idx = out.indexOf(arr1[i]);
+        const dist = idx - firstIdx1;
+        assert((dist % 2) == 0);
+      }
+    });
+  });
+});