shufflecom-calculations 1.2.1 → 1.2.2

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',
@@ -37,12 +46,23 @@ export interface SettleBetVars {
   mainPlayerHand: number[];
   splitPlayerHand: number[];
   dealerHand: number[];
-  mainHandBetAmount: BigNumber;
-  splitHandBetAmount: BigNumber;
+  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: number[];
+  splitPlayerHand: number[];
+  dealerHand: number[];
+  mainHandBetAmount: BigNumber;
+  splitHandBetAmount: BigNumber;
+  boughtInsurance: boolean;
+  hasSplit: boolean;
 }
 
 // Since the values are payout and not profit, it's the profit multiple + 1
@@ -135,41 +155,41 @@ export class Blackjack {
     throw new Error('No available action');
   }
 
-  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: number[], playerCards: 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 };
     }
   }
 
@@ -310,43 +330,79 @@ export class Blackjack {
    * 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 } {
     // 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 { perfectPair, twentyOnePlusThree } = Blackjack.calcSideBetWins(dealerHand[0], playerHand);
+    const playerHand: [number, number] = data.hasSplit ? [data.mainPlayerHand[0], data.splitPlayerHand[0]] : [data.mainPlayerHand[0], data.mainPlayerHand[1]];
 
-    if (perfectPairPayout[perfectPair] && perfectPairAmount.gt(0)) {
-      perfectPairPayoutAmt = perfectPairAmount.times(perfectPairPayout[perfectPair]);
+    const { perfectPair, twentyOnePlusThree } = Blackjack.calcSideBetWins(data.dealerHand[0], playerHand);
+
+    if (perfectPairPayout[perfectPair] && data.perfectPairAmount.gt(0)) {
+      perfectPairPayoutAmt = data.perfectPairAmount.times(perfectPairPayout[perfectPair]);
+    }
+
+    if (twentyOnePlusThreePayout[twentyOnePlusThree] && data.twentyOnePlusThreeAmount.gt(0)) {
+      twentyOnePlusThreePayoutAmt = data.twentyOnePlusThreeAmount.times(twentyOnePlusThreePayout[twentyOnePlusThree]);
     }
 
-    if (twentyOnePlusThreePayout[twentyOnePlusThree] && twentyOnePlusThreeAmount.gt(0)) {
-      twentyOnePlusThreePayoutAmt = twentyOnePlusThreeAmount.times(twentyOnePlusThreePayout[twentyOnePlusThree]);
+    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 mainBetPayout.plus(splitBetPayout).plus(insurancePayout).plus(perfectPairPayoutAmt).plus(twentyOnePlusThreePayoutAmt);
+    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 = splitPlayerHand.length > 0 ? 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

@@ -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/index.ts

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