@arcanahq/cardgames 1.0.0

package/assembly/__tests__/poker/stud.spec.ts

@@ -0,0 +1,190 @@
+// @ts-nocheck
+/**
+ * Tests for Stud Poker showdown evaluator
+ * 
+ * Supports both 5-card and 7-card stud variants
+ * In stud poker, there are no community cards - each player has their own complete hand
+ */
+
+import { describe, test, expect } from "assemblyscript-unittest-framework/assembly";
+import { Card, Suit, Rank, HandType } from "../../cards";
+import { StudShowdownEvaluator } from "../../poker/stud_evaluator";
+
+// Helper function to create cards
+function createCard(rank: string, suit: string): Card {
+  return new Card(suit, rank);
+}
+
+describe("StudShowdownEvaluator", () => {
+  describe("5-Card Stud", () => {
+    test("should evaluate 5-card hands directly", () => {
+      const evaluator = new StudShowdownEvaluator();
+      
+      // Player has 5 cards: A♠ K♠ Q♠ J♠ 10♠ (Royal Flush)
+      const fiveCards = new Array<Card>(5);
+      fiveCards[0] = createCard(Rank.ACE, Suit.SPADES);
+      fiveCards[1] = createCard(Rank.KING, Suit.SPADES);
+      fiveCards[2] = createCard(Rank.QUEEN, Suit.SPADES);
+      fiveCards[3] = createCard(Rank.JACK, Suit.SPADES);
+      fiveCards[4] = createCard(Rank.TEN, Suit.SPADES);
+      
+      const rank = evaluator.evaluateHand(fiveCards, new Array<Card>(0));
+      
+      expect(rank.handType).equal(HandType.ROYAL_FLUSH);
+    });
+
+    test("should use all 5 cards for best hand", () => {
+      const evaluator = new StudShowdownEvaluator();
+      
+      const fiveCards = new Array<Card>(5);
+      fiveCards[0] = createCard(Rank.ACE, Suit.SPADES);
+      fiveCards[1] = createCard(Rank.ACE, Suit.HEARTS);
+      fiveCards[2] = createCard(Rank.KING, Suit.SPADES);
+      fiveCards[3] = createCard(Rank.QUEEN, Suit.SPADES);
+      fiveCards[4] = createCard(Rank.JACK, Suit.SPADES);
+      
+      const bestHand = evaluator.getBestFiveCards(fiveCards, new Array<Card>(0));
+      
+      expect(bestHand.length).equal(5);
+      // Should return all 5 cards
+    });
+
+    test("should compare multiple 5-card stud hands", () => {
+      const evaluator = new StudShowdownEvaluator();
+      
+      // Player 0: Pair of Aces
+      const hand0 = new Array<Card>(5);
+      hand0[0] = createCard(Rank.ACE, Suit.SPADES);
+      hand0[1] = createCard(Rank.ACE, Suit.HEARTS);
+      hand0[2] = createCard(Rank.KING, Suit.SPADES);
+      hand0[3] = createCard(Rank.QUEEN, Suit.SPADES);
+      hand0[4] = createCard(Rank.JACK, Suit.SPADES);
+      
+      // Player 1: Two Pair
+      const hand1 = new Array<Card>(5);
+      hand1[0] = createCard(Rank.ACE, Suit.DIAMONDS);
+      hand1[1] = createCard(Rank.ACE, Suit.CLUBS);
+      hand1[2] = createCard(Rank.KING, Suit.HEARTS);
+      hand1[3] = createCard(Rank.KING, Suit.DIAMONDS);
+      hand1[4] = createCard(Rank.QUEEN, Suit.HEARTS);
+      
+      const holeCardsMap = new Map<i32, Card[]>();
+      holeCardsMap.set(0, hand0);
+      holeCardsMap.set(1, hand1);
+      
+      const result = evaluator.compareHandsShowdown(holeCardsMap, new Array<Card>(0));
+      
+      // Player 1 should win with Two Pair
+      expect(result.winners.length).equal(1);
+      expect(result.winners[0]).equal(1);
+    });
+  });
+
+  describe("7-Card Stud", () => {
+    test("should choose best 5 from 7 cards", () => {
+      const evaluator = new StudShowdownEvaluator();
+      
+      // 7 cards: A♠ K♠ Q♠ J♠ 10♠ 9♠ 8♠
+      // Best 5: A♠ K♠ Q♠ J♠ 10♠ (Royal Flush)
+      const sevenCards = new Array<Card>(7);
+      sevenCards[0] = createCard(Rank.ACE, Suit.SPADES);
+      sevenCards[1] = createCard(Rank.KING, Suit.SPADES);
+      sevenCards[2] = createCard(Rank.QUEEN, Suit.SPADES);
+      sevenCards[3] = createCard(Rank.JACK, Suit.SPADES);
+      sevenCards[4] = createCard(Rank.TEN, Suit.SPADES);
+      sevenCards[5] = createCard(Rank.NINE, Suit.SPADES);
+      sevenCards[6] = createCard(Rank.EIGHT, Suit.SPADES);
+      
+      const rank = evaluator.evaluateHand(sevenCards, new Array<Card>(0));
+      
+      expect(rank.handType).equal(HandType.ROYAL_FLUSH);
+    });
+
+    test("should return best 5 cards from 7", () => {
+      const evaluator = new StudShowdownEvaluator();
+      
+      // 7 cards with best 5 being a flush
+      const sevenCards = new Array<Card>(7);
+      sevenCards[0] = createCard(Rank.ACE, Suit.SPADES);
+      sevenCards[1] = createCard(Rank.KING, Suit.SPADES);
+      sevenCards[2] = createCard(Rank.QUEEN, Suit.SPADES);
+      sevenCards[3] = createCard(Rank.JACK, Suit.SPADES);
+      sevenCards[4] = createCard(Rank.TEN, Suit.SPADES);
+      sevenCards[5] = createCard(Rank.NINE, Suit.HEARTS); // Different suit
+      sevenCards[6] = createCard(Rank.EIGHT, Suit.HEARTS); // Different suit
+      
+      const bestHand = evaluator.getBestFiveCards(sevenCards, new Array<Card>(0));
+      
+      expect(bestHand.length).equal(5);
+      // Should be the 5 spades (flush)
+    });
+
+    test("should compare multiple 7-card stud hands", () => {
+      const evaluator = new StudShowdownEvaluator();
+      
+      // Player 0: 7 cards, best 5 is a flush (A♠ K♠ Q♠ J♠ 10♠)
+      const hand0 = new Array<Card>(7);
+      hand0[0] = createCard(Rank.ACE, Suit.SPADES);
+      hand0[1] = createCard(Rank.KING, Suit.SPADES);
+      hand0[2] = createCard(Rank.QUEEN, Suit.SPADES);
+      hand0[3] = createCard(Rank.JACK, Suit.SPADES);
+      hand0[4] = createCard(Rank.TEN, Suit.SPADES);
+      hand0[5] = createCard(Rank.NINE, Suit.HEARTS);
+      hand0[6] = createCard(Rank.EIGHT, Suit.HEARTS);
+      
+      // Player 1: 7 cards, best 5 is a straight (A♥ K♥ Q♥ J♥ 10♥ - but this is also a flush!)
+      // Use a non-flush straight instead
+      const hand1 = new Array<Card>(7);
+      hand1[0] = createCard(Rank.ACE, Suit.HEARTS);
+      hand1[1] = createCard(Rank.KING, Suit.DIAMONDS);
+      hand1[2] = createCard(Rank.QUEEN, Suit.CLUBS);
+      hand1[3] = createCard(Rank.JACK, Suit.HEARTS);
+      hand1[4] = createCard(Rank.TEN, Suit.DIAMONDS);
+      hand1[5] = createCard(Rank.NINE, Suit.CLUBS);
+      hand1[6] = createCard(Rank.EIGHT, Suit.HEARTS);
+      
+      const holeCardsMap = new Map<i32, Card[]>();
+      holeCardsMap.set(0, hand0);
+      holeCardsMap.set(1, hand1);
+      
+      const result = evaluator.compareHandsShowdown(holeCardsMap, new Array<Card>(0));
+      
+      // Player 0 should win with Flush (beats Straight)
+      expect(result.winners.length).equal(1);
+      expect(result.winners[0]).equal(0);
+    });
+
+    test("should handle ties in 7-card stud", () => {
+      const evaluator = new StudShowdownEvaluator();
+      
+      // Both players have same best 5-card hand
+      const hand0 = new Array<Card>(7);
+      hand0[0] = createCard(Rank.ACE, Suit.SPADES);
+      hand0[1] = createCard(Rank.ACE, Suit.HEARTS);
+      hand0[2] = createCard(Rank.KING, Suit.SPADES);
+      hand0[3] = createCard(Rank.QUEEN, Suit.SPADES);
+      hand0[4] = createCard(Rank.JACK, Suit.SPADES);
+      hand0[5] = createCard(Rank.TEN, Suit.HEARTS);
+      hand0[6] = createCard(Rank.NINE, Suit.HEARTS);
+      
+      const hand1 = new Array<Card>(7);
+      hand1[0] = createCard(Rank.ACE, Suit.DIAMONDS);
+      hand1[1] = createCard(Rank.ACE, Suit.CLUBS);
+      hand1[2] = createCard(Rank.KING, Suit.HEARTS);
+      hand1[3] = createCard(Rank.QUEEN, Suit.HEARTS);
+      hand1[4] = createCard(Rank.JACK, Suit.HEARTS);
+      hand1[5] = createCard(Rank.TEN, Suit.DIAMONDS);
+      hand1[6] = createCard(Rank.NINE, Suit.DIAMONDS);
+      
+      const holeCardsMap = new Map<i32, Card[]>();
+      holeCardsMap.set(0, hand0);
+      holeCardsMap.set(1, hand1);
+      
+      const result = evaluator.compareHandsShowdown(holeCardsMap, new Array<Card>(0));
+      
+      // Both have pair of Aces with same kickers
+      expect(result.winners.length).equal(2);
+    });
+  });
+});
+

package/assembly/__tests__/poker/test.ts

@@ -0,0 +1,13 @@
+// @ts-nocheck
+/**
+ * Test entry point for poker utilities
+ */
+
+import "./stakes.spec";
+import "./pots.spec";
+import "./betting_round.spec";
+import "./showdown.spec";
+import "./six_plus.spec";
+import "./stud.spec";
+import "./omaha.spec";
+

package/assembly/__tests__/test.ts

@@ -0,0 +1,11 @@
+// @ts-nocheck
+/**
+ * Test entry point for @cardgames library
+ */
+
+import "./blackjack/actions/test";
+import "./blackjack/rules.spec";
+import "./deck/deck.spec";
+import "./deck/shoe.spec";
+import "./poker/test";
+

package/assembly/blackjack/actions.ts

@@ -0,0 +1,191 @@
+// @ts-nocheck
+/**
+ * Blackjack Action Processing Utilities
+ * 
+ * Provides reusable blackjack action processing logic that can be used
+ * by any blackjack implementation. This library handles the game logic
+ * while allowing implementations to manage their own state structure.
+ */
+
+import { BlackjackRules } from "./rules";
+
+/**
+ * Available actions result
+ */
+export class AvailableActions {
+  canStand: bool = false;
+  canDouble: bool = false;
+  canSplit: bool = false;
+  canSurrender: bool = false;
+}
+
+/**
+ * Calculate available actions for a hand based on rules
+ */
+export function calculateAvailableActions(
+  handCardsLength: i32,
+  handIsFromSplit: bool,
+  handIsSplitAces: bool,
+  handIsStanding: bool,
+  handIsBusted: bool,
+  gamePhase: string,
+  playerHandsCount: i32,
+  canSplit: bool, // Pre-calculated: whether cards can be split
+  rules: BlackjackRules
+): AvailableActions {
+  const result = new AvailableActions();
+  
+  // Stand is always available if hand is not busted and not already standing
+  // (and we're in the playing phase)
+  if (gamePhase == "PLAYING" && !handIsStanding && !handIsBusted) {
+    result.canStand = true;
+    
+    // Other actions are only available on first two cards
+    if (handCardsLength == 2 && !handIsSplitAces) {
+      result.canDouble = true;
+      if (handIsFromSplit && !rules.doubleAfterSplit) {
+        result.canDouble = false;
+      }
+      result.canSurrender = rules.surrenderAllowed && !handIsFromSplit;
+      if (canSplit && playerHandsCount < rules.maxSplitHands) {
+        result.canSplit = true;
+      }
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * Check if dealer should hit based on rules
+ */
+export function shouldDealerHit(
+  handValue: i32,
+  dealerStandValue: i32,
+  hitOnSoft17: bool,
+  isSoftHand: bool
+): bool {
+  // Below stand value - must hit
+  if (handValue < dealerStandValue) {
+    return true;
+  }
+  
+  // Above stand value - stand
+  if (handValue > dealerStandValue) {
+    return false;
+  }
+  
+  // At stand value - check if soft 17
+  if (handValue == dealerStandValue && hitOnSoft17) {
+    return isSoftHand;
+  }
+  
+  return false;
+}
+
+/**
+ * Validate action can be performed in current phase
+ */
+export function validateActionPhase(gamePhase: string, action: string, requiredPhase: string): void {
+  if (gamePhase != requiredPhase) {
+    throw new Error(`Can only perform ${action} during ${requiredPhase} phase`);
+  }
+}
+
+/**
+ * Validate hand exists and is active
+ */
+export function validateActiveHand(currentHandIndex: i32, playerHandsLength: i32): void {
+  if (currentHandIndex < 0 || currentHandIndex >= playerHandsLength) {
+    throw new Error("No active hand found");
+  }
+}
+
+/**
+ * Validate hand can be hit
+ */
+export function validateCanHit(handIsStanding: bool, handIsBusted: bool, handIsSplitAces: bool): void {
+  if (handIsStanding || handIsBusted || handIsSplitAces) {
+    throw new Error("Cannot hit on this hand");
+  }
+}
+
+/**
+ * Validate hand can be stood
+ */
+export function validateCanStand(handIsStanding: bool, handIsBusted: bool): void {
+  if (handIsStanding) {
+    throw new Error("Hand is already standing");
+  }
+  if (handIsBusted) {
+    throw new Error("Cannot stand on busted hand");
+  }
+}
+
+/**
+ * Validate hand can be doubled
+ */
+export function validateCanDouble(
+  handCardsLength: i32,
+  handIsSplitAces: bool,
+  handIsFromSplit: bool,
+  rules: BlackjackRules
+): void {
+  if (handCardsLength != 2) {
+    throw new Error("Can only double on first two cards");
+  }
+  
+  if (handIsSplitAces) {
+    throw new Error("Cannot double on split aces");
+  }
+  
+  if (handIsFromSplit && !rules.doubleAfterSplit) {
+    throw new Error("Cannot double after split");
+  }
+}
+
+/**
+ * Validate hand can be split
+ */
+export function validateCanSplit(
+  handCardsLength: i32,
+  playerHandsCount: i32,
+  canSplit: bool, // Pre-calculated: whether cards can be split
+  rules: BlackjackRules
+): void {
+  if (handCardsLength != 2) {
+    throw new Error("Can only split on first two cards");
+  }
+  
+  if (playerHandsCount >= rules.maxSplitHands) {
+    throw new Error("Maximum number of split hands reached");
+  }
+  
+  if (!canSplit) {
+    throw new Error("Cards cannot be split");
+  }
+}
+
+/**
+ * Validate hand can be surrendered
+ */
+export function validateCanSurrender(
+  handCardsLength: i32,
+  handIsFromSplit: bool,
+  rules: BlackjackRules
+): void {
+  if (!rules.surrenderAllowed) {
+    throw new Error("Surrender is not allowed");
+  }
+  
+  if (handCardsLength != 2 || handIsFromSplit) {
+    throw new Error("Can only surrender on first two cards of original hand");
+  }
+}
+
+/**
+ * Check if insurance should be offered
+ */
+export function shouldOfferInsurance(dealerUpCardRank: string, rules: BlackjackRules): bool {
+  return dealerUpCardRank == "A" && rules.insuranceOffered;
+}