dond/index.js

A library for simulating the hit UK/US game show.

let shuffle = require('shuffle-array');

let _startingBriefcases = new WeakMap();
let _casesToPickEachRound = new WeakMap();
let _isGameInProgress = new WeakMap();
let _currentCases = new WeakMap();
let _currentPlayer = new WeakMap();
let _roundNumber = new WeakMap();
let _casesToPickThisRound = new WeakMap();
let _isInLivePlay = new WeakMap();
let _previousOffers = new WeakMap();

class DondGame {
  constructor(briefcases, casesToPickEachRound) {
    _startingBriefcases.set(this, briefcases);
    _casesToPickEachRound.set(this, casesToPickEachRound);
    _isGameInProgress.set(this, false);
    _currentCases.set(this, []);
    _currentPlayer.set(this, '');
    _roundNumber.set(this, 0);
    _casesToPickThisRound.set(this, 0);
    _isInLivePlay.set(this, false);
    _previousOffers.set(this, []);
  }

  get isGameSane() {
    let briefcases = _startingBriefcases.get(this);
    let casesToPick = _casesToPickEachRound.get(this);
    return briefcases.length - casesToPick.reduce( (a, b) => a + b, 0 ) === 2;
  }

  get isGameInProgress() {
    return !!_isGameInProgress.get(this);
  }

  get isInLivePlay() {
    return !!_isInLivePlay.get(this);
  }

  get currentPlayer() {
    return _currentPlayer.get(this);
  }

  get roundNumber() {
    return _roundNumber.get(this);
  }

  get casesToPick() {
    return _casesToPickThisRound.get(this);
  }

  get lastOffer() {
    let previousOffers = _previousOffers.get(this);
    return previousOffers[previousOffers.length - 1];
  }

  reset() {
    _isGameInProgress.set(this, false);
    _currentCases.set(this, []);
    _currentPlayer.set(this, '');
    _roundNumber.set(this, 0);
    _casesToPickThisRound.set(this, 0);
    _isInLivePlay.set(this, false);
    _previousOffers.set(this, []);
  }

  startGame(playerName) {
    _currentPlayer.set(this, playerName);
    _isGameInProgress.set(this, true);
    let shuffledCases = shuffle(_startingBriefcases.get(this), { copy: true });
    shuffledCases = shuffledCases.map( (currentCase, index) => {
      currentCase.number = index + 1;
      currentCase.isPlayerCase = false;
      currentCase.isSelectedCase = false;
      return currentCase;
    } );
    _currentCases.set(this, shuffledCases);
  }

  pickStartingCase(caseNumber) {
    let currentCases = _currentCases.get(this);
    if (Number.isNaN(caseNumber) || caseNumber < 1 || caseNumber > currentCases.length) {
      return NaN;
    }

    currentCases[caseNumber - 1].isPlayerCase = true;
    _roundNumber.set(this, 1);
    _casesToPickThisRound.set(this, _casesToPickEachRound.get(this)[0]);
    return caseNumber;
  }

  pickCase(caseNumber) {
    let currentCases = _currentCases.get(this);
    if (Number.isNaN(caseNumber) || caseNumber < 1 || caseNumber > currentCases.length) {
      return undefined;
    }

    let chosenCase = currentCases[caseNumber - 1];
    if (chosenCase.isSelectedCase === true || chosenCase.isPlayerCase === true) {
      // The same case can't be selected twice.
      return undefined;
    }
    chosenCase.isSelectedCase = true;
    _casesToPickThisRound.set(this, _casesToPickThisRound.get(this) - 1);
    return chosenCase.presentation;
  }

  revealPlayerCase() {
    _isInLivePlay.set(this, false);
    _isGameInProgress.set(this, false);
    return _currentCases.get(this).filter(c => c.isPlayerCase).pop().presentation;
  }

  sayNoDeal() {
    let oldRoundNumber = _roundNumber.get(this);
    let casesToPick = _casesToPickEachRound.get(this)[oldRoundNumber];
    _casesToPickThisRound.set(this, casesToPick);
    _roundNumber.set(this, oldRoundNumber + 1);
    return !!casesToPick;
  }

  sayDeal() {
    _isInLivePlay.set(this, false);
  }

  getPlayerCase() {
    return _currentCases.get(this).filter(c => c.isPlayerCase).map(c => c.number).pop();
  }

  getAvailableCases() {
    return _currentCases.get(this).filter(c => !c.isPlayerCase && !c.isSelectedCase).map(c => c.number);
  }

  getOffer() {
    let availableCases = _currentCases.get(this).filter(c => !c.isSelectedCase);
    let moneySum = availableCases.map(c => c.value).reduce( (a, b) => a + b, 0 );
    let avg = (moneySum * 1.0) / availableCases.length;
    let min = Math.floor(avg * 0.85);
    let max = Math.ceil(avg * 1.05);
    let offer = Math.floor(Math.random() * (max - min + 1)) + min;
    _previousOffers.get(this).push(offer);
    return offer;
  }

  getValuesInPlay() {
    return _currentCases.get(this).filter(c => !c.isSelectedCase).sort( (a, b) => a.value < b.value ? -1 : a.value > b.value ? 1 : 0 ).map(c => c.presentation);
  }

  getAllCases() {
    return _currentCases.get(this);
  }
}

module.exports = DondGame;