@arcanahq/cardgames 1.0.0

package/assembly/deck/index.ts

@@ -0,0 +1,9 @@
+// @ts-nocheck
+/**
+ * Deck Management Module
+ * 
+ * Re-exports all deck utilities
+ */
+
+export * from "./deck";
+

package/assembly/index.ts

@@ -0,0 +1,28 @@
+// @ts-nocheck
+/**
+ * Card Games Library
+ * 
+ * Provides reusable card game logic and blackjack action processing
+ */
+
+// Re-export card game utilities
+export * from "./cards";
+export * from "./cardgames";
+export * from "./poker";
+
+// Re-export blackjack-specific modules
+export * from "./blackjack/blackjack";
+export * from "./blackjack/rules";
+export * from "./blackjack/actions";
+
+// Re-export cash game utilities
+export * from "./cashgames";
+
+// Re-export deck management
+export * from "./deck";
+
+// Re-export poker game utilities
+export * from "./poker/poker_game_types";
+export * from "./poker/poker_game_utils";
+
+

package/assembly/poker/index.ts

@@ -0,0 +1,17 @@
+// @ts-nocheck
+/**
+ * Poker Game Module
+ * 
+ * Re-exports all poker game utilities
+ */
+
+export * from "./poker_game_types";
+export * from "./poker_game_utils";
+export * from "./showdown_evaluator";
+export * from "./showdown";
+export * from "./six_plus_showdown";
+export * from "./variants";
+export * from "./stud_evaluator";
+export * from "./omaha_evaluator";
+export * from "./variant_utils";
+

package/assembly/poker/omaha_evaluator.ts

@@ -0,0 +1,121 @@
+// @ts-nocheck
+/**
+ * Omaha Poker Showdown Evaluator
+ * 
+ * Evaluator for Omaha and Omaha Hi-Lo variants.
+ * In Omaha, players receive 4 hole cards and must use exactly 2 of them
+ * combined with exactly 3 community cards to make their best 5-card hand.
+ */
+
+import { Card, HandRank } from "../cards";
+import { ShowdownEvaluator } from "./showdown_evaluator";
+import { evaluateHand } from "../poker";
+
+/**
+ * Omaha showdown evaluator
+ * Players must use exactly 2 hole cards and 3 community cards
+ */
+export class OmahaShowdownEvaluator extends ShowdownEvaluator {
+  /**
+   * Evaluate an Omaha hand
+   * Must use exactly 2 hole cards and 3 community cards
+   * 
+   * @param holeCards 4 hole cards (must use exactly 2)
+   * @param communityCards 5 community cards (must use exactly 3)
+   */
+  evaluateHand(holeCards: Card[], communityCards: Card[]): HandRank {
+    if (holeCards.length !== 4 || communityCards.length !== 5) {
+      // Invalid hand structure for Omaha
+      return new HandRank(1, []); // Return high card as fallback
+    }
+    
+    // Try all combinations of 2 hole cards and 3 community cards
+    let bestRank: HandRank | null = null;
+    
+    // All combinations of 2 hole cards
+    for (let i = 0; i < holeCards.length - 1; i++) {
+      for (let j = i + 1; j < holeCards.length; j++) {
+        const twoHole = new Array<Card>(2);
+        twoHole[0] = holeCards[i];
+        twoHole[1] = holeCards[j];
+        
+        // All combinations of 3 community cards
+        for (let k = 0; k < communityCards.length - 2; k++) {
+          for (let l = k + 1; l < communityCards.length - 1; l++) {
+            for (let m = l + 1; m < communityCards.length; m++) {
+              const threeCommunity = new Array<Card>(3);
+              threeCommunity[0] = communityCards[k];
+              threeCommunity[1] = communityCards[l];
+              threeCommunity[2] = communityCards[m];
+              
+              // Evaluate this 5-card combination
+              const rank = evaluateHand(twoHole, threeCommunity);
+              
+              if (bestRank === null || rank.compare(bestRank) > 0) {
+                bestRank = rank;
+              }
+            }
+          }
+        }
+      }
+    }
+    
+    return bestRank !== null ? bestRank : new HandRank(1, []);
+  }
+  
+  /**
+   * Get best 5-card hand for Omaha
+   * Returns the 2 hole cards + 3 community cards that form the best hand
+   */
+  getBestFiveCards(holeCards: Card[], communityCards: Card[]): Card[] {
+    if (holeCards.length !== 4 || communityCards.length !== 5) {
+      return new Array<Card>(0);
+    }
+    
+    let bestRank: HandRank | null = null;
+    let bestCards: Card[] | null = null;
+    
+    // Try all combinations of 2 hole cards and 3 community cards
+    for (let i = 0; i < holeCards.length - 1; i++) {
+      for (let j = i + 1; j < holeCards.length; j++) {
+        const twoHole = new Array<Card>(2);
+        twoHole[0] = holeCards[i];
+        twoHole[1] = holeCards[j];
+        
+        for (let k = 0; k < communityCards.length - 2; k++) {
+          for (let l = k + 1; l < communityCards.length - 1; l++) {
+            for (let m = l + 1; m < communityCards.length; m++) {
+              const threeCommunity = new Array<Card>(3);
+              threeCommunity[0] = communityCards[k];
+              threeCommunity[1] = communityCards[l];
+              threeCommunity[2] = communityCards[m];
+              
+              const rank = evaluateHand(twoHole, threeCommunity);
+              
+              if (bestRank === null || rank.compare(bestRank) > 0) {
+                bestRank = rank;
+                // Combine the cards
+                bestCards = new Array<Card>(5);
+                bestCards[0] = twoHole[0];
+                bestCards[1] = twoHole[1];
+                bestCards[2] = threeCommunity[0];
+                bestCards[3] = threeCommunity[1];
+                bestCards[4] = threeCommunity[2];
+              }
+            }
+          }
+        }
+      }
+    }
+    
+    return bestCards !== null ? bestCards : new Array<Card>(0);
+  }
+  
+  /**
+   * Compare hands (same as standard)
+   */
+  compareHands(hand1: HandRank, hand2: HandRank): i32 {
+    return hand1.compare(hand2);
+  }
+}
+

package/assembly/poker/poker_game_types.ts

@@ -0,0 +1,233 @@
+// @ts-nocheck
+/**
+ * Poker Game Types
+ * 
+ * Generic types for poker-style card games including blinds, antes, pots, and rake
+ */
+
+/**
+ * Stakes configuration for poker games
+ * Defines small blind, big blind, and ante amounts
+ */
+export class Stakes {
+  sb: i64 = 0; // Small blind
+  bb: i64 = 0; // Big blind
+  ante: i64 = 0; // Ante per player
+  
+  constructor(sb: i64 = 0, bb: i64 = 0, ante: i64 = 0) {
+    this.sb = sb;
+    this.bb = bb;
+    this.ante = ante;
+  }
+  
+  clone(): Stakes {
+    return new Stakes(this.sb, this.bb, this.ante);
+  }
+}
+
+/**
+ * Ante type configuration
+ */
+export class AnteType {
+  static readonly NONE: string = "NONE";
+  static readonly FIXED: string = "FIXED"; // Fixed ante per player
+  static readonly PERCENTAGE: string = "PERCENTAGE"; // Ante as percentage of big blind
+}
+
+/**
+ * Pot structure for poker games
+ * Supports side pots and run-it multiple times
+ */
+export class Pot {
+  potId: i32 = 0;
+  amount: i64 = 0;
+  eligibleSeats: i32[] = []; // Seat IDs eligible to win this pot
+  locked: bool = false; // Whether pot is locked (no further contributions)
+  runCountForPot: i32 = 1; // Number of runs for run-it multiple times
+  splitAmountsPerRun: i64[] = []; // Amount per run if split
+  
+  constructor(
+    potId: i32 = 0,
+    amount: i64 = 0,
+    eligibleSeats: i32[] = new Array<i32>(0),
+    locked: bool = false,
+    runCountForPot: i32 = 1,
+    splitAmountsPerRun: i64[] = new Array<i64>(0)
+  ) {
+    this.potId = potId;
+    this.amount = amount;
+    this.eligibleSeats = eligibleSeats;
+    this.locked = locked;
+    this.runCountForPot = runCountForPot;
+    this.splitAmountsPerRun = splitAmountsPerRun;
+  }
+  
+  clone(): Pot {
+    const clonedEligibleSeats = new Array<i32>(this.eligibleSeats.length);
+    for (let i = 0; i < this.eligibleSeats.length; i++) {
+      clonedEligibleSeats[i] = this.eligibleSeats[i];
+    }
+    
+    const clonedSplitAmounts = new Array<i64>(this.splitAmountsPerRun.length);
+    for (let i = 0; i < this.splitAmountsPerRun.length; i++) {
+      clonedSplitAmounts[i] = this.splitAmountsPerRun[i];
+    }
+    
+    return new Pot(
+      this.potId,
+      this.amount,
+      clonedEligibleSeats,
+      this.locked,
+      this.runCountForPot,
+      clonedSplitAmounts
+    );
+  }
+}
+
+/**
+ * Rake configuration for poker games
+ * Note: Uses same structure as cashgames RakeConfig but with additional poker-specific options
+ */
+export class PokerRakeConfig {
+  percentage: f64 = 0.0; // Rake percentage (e.g., 5.0 for 5%)
+  cap: i64 = 0; // Maximum rake per pot (0 = no cap)
+  noFlopNoDrop: bool = false; // No rake if hand doesn't reach flop
+  
+  constructor(percentage: f64 = 0.0, cap: i64 = 0, noFlopNoDrop: bool = false) {
+    this.percentage = percentage;
+    this.cap = cap;
+    this.noFlopNoDrop = noFlopNoDrop;
+  }
+  
+  clone(): PokerRakeConfig {
+    return new PokerRakeConfig(this.percentage, this.cap, this.noFlopNoDrop);
+  }
+}
+
+/**
+ * Result of pot distribution
+ */
+export class PotDistributionResult {
+  payouts: Map<i32, i64>; // Map of seat ID to payout amount
+  rake: i64; // Rake amount deducted
+  
+  constructor(payouts: Map<i32, i64>, rake: i64) {
+    this.payouts = payouts;
+    this.rake = rake;
+  }
+}
+
+/**
+ * Betting round state for poker games
+ * Tracks contributions, current bet, and action state
+ */
+export class BettingRoundState {
+  contribThisRound: Map<i32, i64>; // Contributions this betting round (seat ID -> amount)
+  contribTotal: Map<i32, i64>; // Total contributions this hand (seat ID -> amount)
+  currentBetToMatch: i64 = 0; // Current bet amount that must be matched
+  minRaise: i64 = 0; // Minimum raise amount
+  lastFullRaiseSize: i64 = 0; // Size of last full raise
+  lastAggressorSeatId: i32 = -1; // Seat ID of last player to bet/raise
+  actingSeatId: i32 = -1; // Seat ID of player currently to act
+  
+  constructor() {
+    this.contribThisRound = new Map<i32, i64>();
+    this.contribTotal = new Map<i32, i64>();
+  }
+  
+  /**
+   * Get contribution for a seat this round
+   */
+  getContributionThisRound(seatId: i32): i64 {
+    return this.contribThisRound.has(seatId) ? this.contribThisRound.get(seatId) : 0;
+  }
+  
+  /**
+   * Get total contribution for a seat this hand
+   */
+  getTotalContribution(seatId: i32): i64 {
+    return this.contribTotal.has(seatId) ? this.contribTotal.get(seatId) : 0;
+  }
+  
+  /**
+   * Calculate amount needed to call for a seat
+   */
+  calculateToCall(seatId: i32): i64 {
+    const contrib = this.getContributionThisRound(seatId);
+    const toCall = this.currentBetToMatch - contrib;
+    return toCall > 0 ? toCall : 0;
+  }
+  
+  /**
+   * Reset betting round state for next street
+   */
+  resetRound(): void {
+    this.contribThisRound = new Map<i32, i64>();
+    this.currentBetToMatch = 0;
+    this.lastFullRaiseSize = 0;
+    this.lastAggressorSeatId = -1;
+    this.actingSeatId = -1;
+  }
+  
+  clone(): BettingRoundState {
+    const cloned = new BettingRoundState();
+    cloned.currentBetToMatch = this.currentBetToMatch;
+    cloned.minRaise = this.minRaise;
+    cloned.lastFullRaiseSize = this.lastFullRaiseSize;
+    cloned.lastAggressorSeatId = this.lastAggressorSeatId;
+    cloned.actingSeatId = this.actingSeatId;
+    
+    // Clone maps
+    const contribThisRoundKeys = this.contribThisRound.keys();
+    for (let i = 0; i < contribThisRoundKeys.length; i++) {
+      const key = contribThisRoundKeys[i];
+      cloned.contribThisRound.set(key, this.contribThisRound.get(key));
+    }
+    
+    const contribTotalKeys = this.contribTotal.keys();
+    for (let i = 0; i < contribTotalKeys.length; i++) {
+      const key = contribTotalKeys[i];
+      cloned.contribTotal.set(key, this.contribTotal.get(key));
+    }
+    
+    return cloned;
+  }
+}
+
+/**
+ * Base interface for poker seat
+ * Games should extend this with game-specific fields
+ */
+export class PokerSeatBase {
+  seatId: i32 = 0;
+  playerId: string | null = null;
+  stack: i64 = 0; // Current stack
+  inHand: bool = false; // Whether player is in the current hand
+  allIn: bool = false; // Whether player is all-in
+  hasActedThisRound: bool = false; // Whether player has acted this betting round
+  lastAction: string = ""; // Last action taken (FOLD, CHECK, CALL, BET, RAISE, etc.)
+  
+  constructor(seatId: i32 = 0, playerId: string | null = null, stack: i64 = 0) {
+    this.seatId = seatId;
+    this.playerId = playerId;
+    this.stack = stack;
+  }
+  
+  isEmpty(): bool {
+    const pid = this.playerId;
+    if (pid === null) {
+      return true;
+    }
+    return pid.length === 0;
+  }
+  
+  clone(): PokerSeatBase {
+    const seat = new PokerSeatBase(this.seatId, this.playerId, this.stack);
+    seat.inHand = this.inHand;
+    seat.allIn = this.allIn;
+    seat.hasActedThisRound = this.hasActedThisRound;
+    seat.lastAction = this.lastAction;
+    return seat;
+  }
+}
+