+ // Use a bunch of sorted decks to measure entropy from, populated
+ // as needed.
+ var sortedDecks = [];
+ // Initialize the final entropy value for these cards
+ var entropyInt = BigInteger.ZERO;
+ // Track how many instances of each card have been used, and thus
+ // how many decks are in use.
+ var cardCounts = {};
+ // Track the total bits of entropy that remain, which diminishes as
+ // each card is drawn.
+ var totalBitsLeft = numberOfBits;
+ // Work out entropy contribution of each card drawn
+ for (var i=0; i<base.parts.length; i++) {
+ // Get the card that was drawn
+ var cardLower = base.parts[i];
+ var card = cardLower.toUpperCase();
+ // Initialize the deck for this card if needed, to track how
+ // much entropy it adds.
+ if (!(card in cardCounts)) {
+ cardCounts[card] = 0;
+ }
+ // Get the deck this card is from
+ var deckIndex = cardCounts[card];
+ while (deckIndex > sortedDecks.length-1) {
+ sortedDecks.push(getSortedDeck());
+ }
+ // See how many bits this card contributes (depends on how many
+ // are left in the deck it's from)
+ var deckForCard = sortedDecks[deckIndex];
+ var cardsLeftInDeck = deckForCard.length;
+ var additionalBits = Math.log2(cardsLeftInDeck);
+ // Work out the min and max value for this card
+ var nextTotalBitsLeft = totalBitsLeft - additionalBits;
+ var minPossibleNewEntropy = TWO.pow(nextTotalBitsLeft).subtract(1);
+ var maxPossibleNewEntropy = TWO.pow(totalBitsLeft).subtract(1);
+ var diff = maxPossibleNewEntropy.subtract(minPossibleNewEntropy);
+ // BigInteger aggresively floors numbers which greatly affects
+ // the small numbers. In that case, use native Math library
+ var useBigInt = totalBitsLeft >= 32;
+ if (!useBigInt) {
+ minPossibleNewEntropy = Math.round(Math.pow(2, nextTotalBitsLeft)-1);
+ maxPossibleNewEntropy = Math.round(Math.pow(2, totalBitsLeft)-1);
+ diff = maxPossibleNewEntropy - minPossibleNewEntropy;
+ }
+ // Scale the value between possible min and max depending on
+ // this card value
+ var thisCardIndex = deckForCard.indexOf(card);
+ var toAdd = BigInteger.ZERO;
+ if (cardsLeftInDeck > 1) {
+ if (useBigInt) {
+ toAdd = diff.multiply(thisCardIndex)
+ .divide(deckForCard.length - 1)
+ .add(minPossibleNewEntropy);
+ }
+ else {
+ var ratio = thisCardIndex / (deckForCard.length -1);
+ var f = diff * ratio;
+ toAdd = new BigInteger(f).add(minPossibleNewEntropy);
+ }
+ }
+ // Add this card entropy to existing entropy
+ entropyInt = entropyInt.add(toAdd);
+ // Remove this card from the deck it comes from
+ deckForCard.splice(thisCardIndex,1);
+ // Ensure the next insance of this card uses the next deck
+ cardCounts[card] = cardCounts[card] + 1;
+ // Next card drawn has less total remaining bits to work with
+ totalBitsLeft = nextTotalBitsLeft;