shufflecom-calculations 1.2.1 → 1.2.3

package/src/games/blackjack.ts

@@ -11,6 +11,15 @@ export enum BlackjackAction {
   REJECT_INSURANCE = 'REJECT_INSURANCE',
 }
 
+export enum HandOutcome {
+  WIN = 'WIN', // refers to a win that pays out 2:1. Blackjacks after splits are still considered a HandOutcome.WIN and not HandOutcome.BLACKJACK as the payout is 2:1
+  LOSS = 'LOSS',
+  PUSH = 'PUSH',
+  BLACKJACK = 'BLACKJACK', // split hand can NEVER have a HandOutcome.BLACKJACK as the payout is 2:1 so it's a HandOutcome.WIN
+  PENDING = 'PENDING',
+  NONE = 'NONE', // for split player hand if the user has not split
+}
+
 export enum PerfectPairType {
   PERFECT_PAIR = 'PERFECT_PAIR',
   COLORED_PAIR = 'COLORED_PAIR',
@@ -34,15 +43,26 @@ export enum InsuranceStatus {
 }
 
 export interface SettleBetVars {
-  mainPlayerHand: number[];
-  splitPlayerHand: number[];
-  dealerHand: number[];
-  mainHandBetAmount: BigNumber;
-  splitHandBetAmount: BigNumber;
+  mainPlayerHand: readonly number[];
+  splitPlayerHand: readonly number[];
+  dealerHand: readonly number[];
+  mainBetAmount: BigNumber; // the amount that the user entered when they placed the main bet
   twentyOnePlusThreeAmount: BigNumber;
   perfectPairAmount: BigNumber;
   boughtInsurance: boolean;
   hasSplit: boolean;
+  mainHandDoubleDown: boolean;
+  splitHandDoubleDown: boolean;
+}
+
+interface MainBetPayoutVars {
+  mainPlayerHand: readonly number[];
+  splitPlayerHand: readonly number[];
+  dealerHand: readonly number[];
+  mainHandBetAmount: BigNumber;
+  splitHandBetAmount: BigNumber;
+  boughtInsurance: boolean;
+  hasSplit: boolean;
 }
 
 // Since the values are payout and not profit, it's the profit multiple + 1
@@ -73,8 +93,8 @@ const suitColorMap: Record<Suits, SuitColor> = {
 
 export class Blackjack {
   static availableNextActions(
-    currentPlayerHand: number[],
-    dealerCards: number[],
+    currentPlayerHand: readonly number[],
+    dealerCards: [number],
     insuranceStatus: InsuranceStatus,
     atMainHandAndHasNotSplit: boolean,
   ): BlackjackAction[] {
@@ -103,8 +123,8 @@ export class Blackjack {
   static playingMainHand(
     mainPlayerCards: number[],
     splitPlayerCards: number[],
-    mainPlayerActions: BlackjackAction[],
-    splitPlayerActions: BlackjackAction[],
+    mainPlayerActions: readonly BlackjackAction[],
+    splitPlayerActions: readonly BlackjackAction[],
   ): boolean {
     // still on main hand if main hand < 21 and user has not chosen to double down or stand (as these are the 2 actions that will end the main hand)
     if (
@@ -132,48 +152,48 @@ export class Blackjack {
 
     // main hand busted/ended and no split hand
     // OR main hand busted and split hand busted/ended
-    throw new Error('No available action');
+    return true;
   }
 
-  static calcMainBetMultiplier(dealerCards: number[], playerCards: number[], hasSplit: boolean): BigNumber {
-    const dealerBlackjack = this.isBlackjack(dealerCards.slice(0, 2));
-    const playerBlackjack = this.isBlackjack(playerCards.slice(0, 2));
+  static getHandOutcome(dealerCards: readonly number[], playerCards: readonly number[], hasSplit: boolean): { multiplier: BigNumber; outcome: HandOutcome } {
+    const dealerBlackjack = this.isBlackjack(dealerCards);
+    const playerBlackjack = this.isBlackjack(playerCards);
 
     if (playerBlackjack && !dealerBlackjack && !hasSplit) {
-      return new BigNumber(2.5);
+      return { multiplier: new BigNumber(2.5), outcome: HandOutcome.BLACKJACK };
     }
 
     if (dealerBlackjack && !playerBlackjack) {
-      return new BigNumber(0);
+      return { multiplier: new BigNumber(0), outcome: HandOutcome.LOSS };
     }
 
     if (dealerBlackjack && playerBlackjack) {
-      return new BigNumber(1);
+      return { multiplier: new BigNumber(1), outcome: HandOutcome.PUSH };
     }
 
     // If it reaches here, neither player nor dealer has blackjack
     // if player busted, dealer auto wins
     if (this.hasBusted(playerCards)) {
-      return new BigNumber(0);
+      return { multiplier: new BigNumber(0), outcome: HandOutcome.LOSS };
     }
 
     if (this.hasBusted(dealerCards)) {
-      return new BigNumber(2);
+      return { multiplier: new BigNumber(2), outcome: HandOutcome.WIN };
     }
 
     // Both did not bust, so compare the sum of cards
     const playerSum = this.calcHandValue(playerCards);
     const dealerSum = this.calcHandValue(dealerCards);
     if (playerSum > dealerSum) {
-      return new BigNumber(2);
+      return { multiplier: new BigNumber(2), outcome: HandOutcome.WIN };
     } else if (playerSum < dealerSum) {
-      return new BigNumber(0);
+      return { multiplier: new BigNumber(0), outcome: HandOutcome.LOSS };
     } else {
-      return new BigNumber(1);
+      return { multiplier: new BigNumber(1), outcome: HandOutcome.PUSH };
     }
   }
 
-  static calcSideBetWins(dealerUpCard: number, playerCards: number[]): { perfectPair?: PerfectPairType; twentyOnePlusThree?: TwentyOnePlusThreeType } {
+  static calcSideBetWins(dealerUpCard: number, playerCards: readonly number[]): { perfectPair?: PerfectPairType; twentyOnePlusThree?: TwentyOnePlusThreeType } {
     const results: { perfectPair?: PerfectPairType; twentyOnePlusThree?: TwentyOnePlusThreeType } = {};
     const dealerCardDetails = CardGames.getCardDetails(dealerUpCard);
     const playerCard0 = CardGames.getCardDetails(playerCards[0]);
@@ -236,7 +256,7 @@ export class Blackjack {
     return results;
   }
 
-  static calcHandValue(cards: number[]): number {
+  static calcHandValue(cards: readonly number[]): number {
     // taking Ace as 11 here
     const cardValueMap: Record<CardValue, number> = {
       '2': 2,
@@ -271,21 +291,21 @@ export class Blackjack {
     return cardSum;
   }
 
-  static canBuyInsurance(dealerCards: number[]): boolean {
+  static canBuyInsurance(dealerCards: readonly number[]): boolean {
     // player can only buy insurance if dealer's first card(upcard) is an ace
     return CardGames.getCardDetails(dealerCards[0]).value === 'A';
   }
 
   // Dealer does NOT hit on soft 17 (for our implementation)
-  static shouldDealerHit(dealerCards: number[]): boolean {
+  static shouldDealerHit(dealerCards: readonly number[]): boolean {
     return this.calcHandValue(dealerCards) < 17;
   }
 
-  static hasBusted(cards: number[]): boolean {
+  private static hasBusted(cards: readonly number[]): boolean {
     return this.calcHandValue(cards) > 21;
   }
 
-  static canSplit(mainHand: number[]): boolean {
+  private static canSplit(mainHand: readonly number[]): boolean {
     if (mainHand.length !== 2) {
       return false;
     }
@@ -293,11 +313,11 @@ export class Blackjack {
     return cardActions[0].value === cardActions[1].value;
   }
 
-  static canDoubleDown(playerCards: number[]): boolean {
+  private static canDoubleDown(playerCards: readonly number[]): boolean {
     return playerCards.length === 2;
   }
 
-  static isBlackjack(cards: number[]): boolean {
+  static isBlackjack(cards: readonly number[]): boolean {
     if (cards.length !== 2) {
       return false;
     }
@@ -305,48 +325,98 @@ export class Blackjack {
     return this.calcHandValue(cards) === 21;
   }
 
+  // TODO: Write unit tests for this
+  static playDealerHand(dealerHand: readonly number[], numberOfCardsDealt: number, deck: readonly number[]): number[] {
+    const newDealerHand = [...dealerHand];
+    // while the dealer doesn't have 17 or more, draw a card
+    while (Blackjack.shouldDealerHit(newDealerHand)) {
+      newDealerHand.push(deck[numberOfCardsDealt++]);
+    }
+
+    return newDealerHand;
+  }
+
   /**
    *
    * Called after bet ends. Players can still win insurance or sidebets even if they lose the main bet
    * @returns total payout amount
    */
-  static getPayout({
-    mainPlayerHand,
-    splitPlayerHand,
-    dealerHand,
-    mainHandBetAmount,
-    splitHandBetAmount,
-    twentyOnePlusThreeAmount,
-    // TODO: Include 2 more fields for sidebet win types
-    perfectPairAmount,
-    boughtInsurance,
-    hasSplit,
-  }: SettleBetVars): BigNumber {
+  static getGameOutcome(data: SettleBetVars): { payout: BigNumber; multiplier: BigNumber; mainHandOutcome: HandOutcome; splitHandOutcome: HandOutcome } {
+    if (data.dealerHand.length < 2) {
+      throw new Error('Dealer hole card is missing');
+    }
     // calculate main bet payout for main and split hand
-
-    const mainBetPayout = Blackjack.calcMainBetMultiplier(dealerHand, mainPlayerHand, hasSplit).times(mainHandBetAmount);
-    const splitBetPayout =
-      splitPlayerHand.length > 0 ? Blackjack.calcMainBetMultiplier(dealerHand, splitPlayerHand, hasSplit).times(splitHandBetAmount) : new BigNumber(0);
-
-    // calculate insurance payout (insurance payout is 3:1)
-    const insurancePayout = boughtInsurance && Blackjack.isBlackjack(dealerHand) ? mainHandBetAmount.dividedBy(2).times(3) : new BigNumber(0);
+    const mainHandBetAmount = data.mainHandDoubleDown ? data.mainBetAmount.times(2) : data.mainBetAmount;
+    let splitHandBetAmount = new BigNumber(0);
+    if (data.hasSplit) {
+      splitHandBetAmount = data.splitHandDoubleDown ? data.mainBetAmount.times(2) : data.mainBetAmount;
+    }
 
     // calculate sidebet payouts
     let perfectPairPayoutAmt = new BigNumber(0);
     let twentyOnePlusThreePayoutAmt = new BigNumber(0);
 
-    const playerHand: [number, number] = hasSplit ? [mainPlayerHand[0], splitPlayerHand[0]] : [mainPlayerHand[0], mainPlayerHand[1]];
+    const { mainHandOutcome, payout: mainBetPayout, splitHandOutcome } = Blackjack.getMainBetPayout({ ...data, mainHandBetAmount, splitHandBetAmount });
+
+    const playerHand: [number, number] = data.hasSplit ? [data.mainPlayerHand[0], data.splitPlayerHand[0]] : [data.mainPlayerHand[0], data.mainPlayerHand[1]];
 
-    const { perfectPair, twentyOnePlusThree } = Blackjack.calcSideBetWins(dealerHand[0], playerHand);
+    const { perfectPair, twentyOnePlusThree } = Blackjack.calcSideBetWins(data.dealerHand[0], playerHand);
 
-    if (perfectPairPayout[perfectPair] && perfectPairAmount.gt(0)) {
-      perfectPairPayoutAmt = perfectPairAmount.times(perfectPairPayout[perfectPair]);
+    if (perfectPairPayout[perfectPair] && data.perfectPairAmount.gt(0)) {
+      perfectPairPayoutAmt = data.perfectPairAmount.times(perfectPairPayout[perfectPair]);
     }
 
-    if (twentyOnePlusThreePayout[twentyOnePlusThree] && twentyOnePlusThreeAmount.gt(0)) {
-      twentyOnePlusThreePayoutAmt = twentyOnePlusThreeAmount.times(twentyOnePlusThreePayout[twentyOnePlusThree]);
+    if (twentyOnePlusThreePayout[twentyOnePlusThree] && data.twentyOnePlusThreeAmount.gt(0)) {
+      twentyOnePlusThreePayoutAmt = data.twentyOnePlusThreeAmount.times(twentyOnePlusThreePayout[twentyOnePlusThree]);
     }
 
-    return mainBetPayout.plus(splitBetPayout).plus(insurancePayout).plus(perfectPairPayoutAmt).plus(twentyOnePlusThreePayoutAmt);
+    const payout = mainBetPayout.plus(perfectPairPayoutAmt).plus(twentyOnePlusThreePayoutAmt);
+    const insuranceCost = data.boughtInsurance ? data.mainBetAmount.dividedBy(2) : new BigNumber(0); // insurance costs half of the main bet
+    const totalBetAmount = mainHandBetAmount.plus(splitHandBetAmount).plus(data.perfectPairAmount).plus(data.twentyOnePlusThreeAmount).plus(insuranceCost);
+
+    let multiplier = payout.dividedBy(totalBetAmount);
+
+    // when the user bets $0, assume an initial bet of $1 to calculate the multiplier
+    if (totalBetAmount.isZero()) {
+      const mainHandBetAmount = data.mainHandDoubleDown ? new BigNumber(2) : new BigNumber(1);
+      let splitHandBetAmount = new BigNumber(0);
+      if (data.hasSplit) {
+        splitHandBetAmount = data.splitHandDoubleDown ? new BigNumber(2) : new BigNumber(1);
+      }
+
+      const insuranceCost = data.boughtInsurance ? new BigNumber(0.5) : new BigNumber(0); // insurance costs half of the main bet
+      const totalBetAmount = mainHandBetAmount.plus(splitHandBetAmount).plus(insuranceCost);
+
+      multiplier = Blackjack.getMainBetPayout({ ...data, mainHandBetAmount, splitHandBetAmount }).payout.dividedBy(totalBetAmount);
+    }
+
+    return { payout, multiplier, mainHandOutcome, splitHandOutcome };
+  }
+
+  private static getMainBetPayout({
+    mainPlayerHand,
+    splitPlayerHand,
+    dealerHand,
+    mainHandBetAmount,
+    splitHandBetAmount,
+    boughtInsurance,
+    hasSplit,
+  }: MainBetPayoutVars) {
+    const { multiplier: mainHandMultiplier, outcome: mainHandOutcome } = Blackjack.getHandOutcome(dealerHand, mainPlayerHand, hasSplit);
+    const mainHandPayout = mainHandMultiplier.times(mainHandBetAmount);
+
+    const { multiplier: splitHandMultiplier, outcome: splitHandOutcome } = Blackjack.getHandOutcome(dealerHand, splitPlayerHand, hasSplit);
+
+    const splitHandPayout = hasSplit ? splitHandMultiplier.times(splitHandBetAmount) : new BigNumber(0);
+
+    // calculate insurance payout (insurance payout is 3:1)
+    // insurance won't be claimed if double down occurs, so double downs won't affect insurance payout even though it doubles the mainHandBetAmount
+    const insurancePayout = boughtInsurance && Blackjack.isBlackjack(dealerHand) ? mainHandBetAmount.dividedBy(2).times(3) : new BigNumber(0);
+
+    return {
+      mainHandOutcome,
+      splitHandOutcome: hasSplit ? splitHandOutcome : HandOutcome.NONE,
+      payout: mainHandPayout.plus(splitHandPayout).plus(insurancePayout),
+    };
   }
 }

package/src/games/cardGames.ts

@@ -52,7 +52,7 @@ export class CardGames {
     return { suit, value: value as CardValue };
   }
 
-  static getCardDetailsArr(cardNums: number[]): CardDetail[] {
+  static getCardDetailsArr(cardNums: readonly number[]): CardDetail[] {
     return cardNums.map((cardNum) => this.getCardDetails(cardNum));
   }
 
@@ -105,3 +105,58 @@ export class CardGames {
 // ]
 
 // A = 1, 2 = 2 ,...10 = 10, J = 11, Q = 12, K = 13
+/**
+ * 0: ♦2
+ * 1: ♥2
+ * 2: ♠2
+ * 3: ♣2
+ * 4: ♦3
+ * 5: ♥3
+ * 6: ♠3
+ * 7: ♣3
+ * 8: ♦4
+ * 9: ♥4
+ * 10: ♠4
+ * 11: ♣4
+ * 12: ♦5
+ * 13: ♥5
+ * 14: ♠5
+ * 15: ♣5
+ * 16: ♦6
+ * 17: ♥6
+ * 18: ♠6
+ * 19: ♣6
+ * 20: ♦7
+ * 21: ♥7
+ * 22: ♠7
+ * 23: ♣7
+ * 24: ♦8
+ * 25: ♥8
+ * 26: ♠8
+ * 27: ♣8
+ * 28: ♦9
+ * 29: ♥9
+ * 30: ♠9
+ * 31: ♣9
+ * 32: ♦10
+ * 33: ♥10
+ * 34: ♠10
+ * 35: ♣10
+ * 36: ♦J
+ * 37: ♥J
+ * 38: ♠J
+ * 39: ♣J
+ * 40: ♦Q
+ * 41: ♥Q
+ * 42: ♠Q
+ * 43: ♣Q
+ * 44: ♦K
+ * 45: ♥K
+ * 46: ♠K
+ * 47: ♣K
+ * 48: ♦A
+ * 49: ♥A
+ * 50: ♠A
+ * 51: ♣A
+ *
+ */

package/src/games/hilo.ts

@@ -4,7 +4,6 @@ import { CardGames } from './cardGames';
 
 const TOTAL_CARD = new BigNumber(13);
 
-// TODO: Remove the card detail stuff from here
 /**
  * For Ace card, since it's the lowest card,
  * - SAME_OR_ABOVE -> ABOVE
@@ -29,11 +28,6 @@ export enum Suits {
   CLUBS = 'CLUBS',
 }
 
-export interface CardDetail {
-  suit: Suits;
-  value: string;
-}
-
 export class Hilo {
   static isGuessCorrect(previousCard: number, guess: HiloGuess, result: number) {
     const previousCardValue = CardGames.toComparableNo(previousCard);

package/src/index.ts

@@ -16,4 +16,5 @@ export {
   TwentyOnePlusThreeType,
   perfectPairPayout,
   twentyOnePlusThreePayout,
+  HandOutcome,
 } from './games/blackjack';