fix: incorrect logic when checking high card

fixes #5, #7

Author: devklick

src/utilities/deckUtilities.test.ts

@@ -0,0 +1,118 @@
+import { CardRankMetadataMap } from "../components/Card/Card";
+import { determineWinner, BestHand } from "./deckUtilities";
+describe("deckUtilities", () => {
+  describe("determineWinner", () => {
+    let dealerHand: BestHand;
+    let playerHand: BestHand;
+
+    beforeEach(() => {
+      dealerHand = {
+        cards: [
+          {
+            card: { facing: "Up", rank: "Ace", suit: "Club" },
+            rankRelativeValueUsed: Math.min(
+              ...CardRankMetadataMap["Ace"].relativeValues
+            ),
+            rankValueUsed: Math.min(...CardRankMetadataMap["Ace"].values),
+          },
+        ],
+        score: 1,
+      };
+      playerHand = {
+        cards: [
+          {
+            card: { facing: "Up", rank: "Ace", suit: "Diamond" },
+            rankRelativeValueUsed: Math.min(
+              ...CardRankMetadataMap["Ace"].relativeValues
+            ),
+            rankValueUsed: Math.min(...CardRankMetadataMap["Ace"].values),
+          },
+        ],
+        score: 1,
+      };
+    });
+
+    describe("Winner based on score", () => {
+      it("Should return Dealer when dealer score is greater than player score", () => {
+        dealerHand.score = playerHand.score + 1;
+        const result = determineWinner(playerHand, dealerHand);
+        expect(result.winner).toBe("Dealer");
+        expect(result.winnerText).toBe("Dealer wins with a high score");
+      });
+      it("Should return Player when player score is greater than dealer score", () => {
+        playerHand.score = dealerHand.score + 1;
+        const result = determineWinner(playerHand, dealerHand);
+        expect(result.winner).toBe("Player");
+        expect(result.winnerText).toBe("Player wins with a high score");
+      });
+    });
+
+    describe("Winner based on number of cards", () => {
+      it("Should return Dealer when dealer has more cards than player", () => {
+        dealerHand.cards.push({
+          card: { facing: "Up", rank: "Eight", suit: "Diamond" },
+          rankRelativeValueUsed: 8,
+          rankValueUsed: 8,
+        });
+        dealerHand.score = playerHand.score;
+        const result = determineWinner(playerHand, dealerHand);
+        expect(result.winner).toBe("Dealer");
+        expect(result.winnerText).toBe("Dealer wins with the most cards");
+      });
+      it("Should return Player when player has more cards than player", () => {
+        playerHand.cards.push({
+          card: { facing: "Up", rank: "Eight", suit: "Diamond" },
+          rankRelativeValueUsed: 8,
+          rankValueUsed: 8,
+        });
+        playerHand.score = dealerHand.score;
+        const result = determineWinner(playerHand, dealerHand);
+        expect(result.winner).toBe("Player");
+        expect(result.winnerText).toBe("Player wins with the most cards");
+      });
+    });
+
+    describe("Winner based on high card", () => {
+      it("Should return Dealer when dealers high card is greater than players", () => {
+        dealerHand.cards.push({
+          card: { facing: "Up", rank: "Eight", suit: "Diamond" },
+          rankRelativeValueUsed: 8,
+          rankValueUsed: 8,
+        });
+        playerHand.cards.push({
+          card: { facing: "Up", rank: "Seven", suit: "Diamond" },
+          rankRelativeValueUsed: 7,
+          rankValueUsed: 7,
+        });
+        dealerHand.score = playerHand.score;
+        const result = determineWinner(playerHand, dealerHand);
+        expect(result.winner).toBe("Dealer");
+        expect(result.winnerText).toBe("Dealer wins with a high card");
+      });
+      it("Should return Player when player has more cards than player", () => {
+        dealerHand.cards.push({
+          card: { facing: "Up", rank: "Seven", suit: "Diamond" },
+          rankRelativeValueUsed: 7,
+          rankValueUsed: 7,
+        });
+        playerHand.cards.push({
+          card: { facing: "Up", rank: "Eight", suit: "Diamond" },
+          rankRelativeValueUsed: 8,
+          rankValueUsed: 8,
+        });
+        playerHand.score = dealerHand.score;
+        const result = determineWinner(playerHand, dealerHand);
+        expect(result.winner).toBe("Player");
+        expect(result.winnerText).toBe("Player wins with a high card");
+      });
+    });
+
+    it("Should return no winner when both players have same card values, count and high card", () => {
+      const result = determineWinner(playerHand, dealerHand);
+      expect(result.winner).toBeNull();
+      expect(result.winnerText).toBe(
+        "Draw! Same hand value, number of cards, and card ranks!"
+      );
+    });
+  });
+});

src/utilities/deckUtilities.ts

@@ -167,54 +167,89 @@ export const determineWinner = (
   playerHand: BestHand,
   dealerHand: BestHand
 ): GameResult => {
-  if (playerHand.score > dealerHand.score) {
-    return {
-      winner: "Player",
-      winnerText: "Player wins with a high score",
-    };
-  }
-  if (dealerHand.score > playerHand.score) {
-    return {
-      winner: "Dealer",
-      winnerText: "Dealer wins with a high score",
-    };
-  }
-  if (playerHand.cards.length > dealerHand.cards.length) {
-    return {
-      winner: "Player",
-      winnerText: "Player wins with the most cards",
-    };
+  const scoreWinner = getScoreWinner(playerHand.score, dealerHand.score);
+
+  if (scoreWinner) {
+    return scoreWinner;
   }
-  if (dealerHand.cards.length > playerHand.cards.length) {
-    return {
-      winner: "Dealer",
-      winnerText: "Dealer wins with the most cards",
-    };
+
+  const cardCountWinner = getCardCountWinner(
+    playerHand.cards,
+    dealerHand.cards
+  );
+
+  if (cardCountWinner) {
+    return cardCountWinner;
   }
-  const cardCount = playerHand.cards.length;
-  let currentCardIndex = 0;
-  while (currentCardIndex < cardCount) {
-    if (
-      playerHand.cards[currentCardIndex].rankValueUsed >
-      dealerHand.cards[currentCardIndex].rankValueUsed
-    ) {
-      return {
-        winner: "Player",
-        winnerText: "Player wins with a high card",
-      };
-    }
-    if (
-      dealerHand.cards[currentCardIndex].rankValueUsed >
-      playerHand.cards[currentCardIndex].rankValueUsed
-    ) {
-      return {
-        winner: "Dealer",
-        winnerText: "Dealer wins with a high card",
-      };
-    }
+
+  const highCardWinner = getHighCardWinner(playerHand.cards, dealerHand.cards);
+
+  if (highCardWinner) {
+    return highCardWinner;
   }
+
   return {
     winner: null,
     winnerText: "Draw! Same hand value, number of cards, and card ranks!",
   };
 };
+
+const getHighestCardValue = (cards: CardValue[]) => {
+  return cards.sort((a, b) => b.rankValueUsed - a.rankValueUsed)[0];
+};
+
+const getHighCardWinner = (
+  playerCards: CardValue[],
+  dealerCards: CardValue[]
+): GameResult | null => {
+  const playerHighCard = getHighestCardValue(playerCards).rankValueUsed;
+  console.log("playerHighCard", playerHighCard);
+  const dealerHighCard = getHighestCardValue(dealerCards).rankValueUsed;
+  console.log("dealerHighCard", dealerHighCard);
+
+  const winner = getPlayerWithHighestValue(playerHighCard, dealerHighCard);
+  if (!winner) return null;
+
+  return {
+    winner,
+    winnerText: `${winner} wins with a high card`,
+  };
+};
+
+const getScoreWinner = (
+  playerScore: number,
+  dealerScore: number
+): GameResult | null => {
+  const winner = getPlayerWithHighestValue(playerScore, dealerScore);
+  if (!winner) return null;
+
+  return {
+    winner,
+    winnerText: `${winner} wins with a high score`,
+  };
+};
+
+const getCardCountWinner = (
+  playerCards: CardValue[],
+  dealerCards: CardValue[]
+) => {
+  const winner = getPlayerWithHighestValue(
+    playerCards.length,
+    dealerCards.length
+  );
+  if (!winner) return null;
+
+  return {
+    winner,
+    winnerText: `${winner} wins with the most cards`,
+  };
+};
+
+const getPlayerWithHighestValue = (
+  playerValue: number,
+  dealerValue: number
+): Participant | null => {
+  if (playerValue > dealerValue) return "Player";
+  if (dealerValue > playerValue) return "Dealer";
+  return null;
+};