@block52/poker-vm-sdk 1.6.0 → 1.7.0

package/dist/index.d.ts

@@ -46073,6 +46073,16 @@ declare class PokerSolver {
      * Find the best 5-card hand from 7 cards
      */
     static findBestHand(cards: Card[]): HandEvaluation;
+    /**
+     * Find the best Omaha hand: EXACTLY 2 of the 4 hole cards and EXACTLY 3 of
+     * the 5 board cards — C(4,2) x C(5,3) = 60 candidates, ranked like Hold'em.
+     * Mirrors the engine's FindBestOmahaHand (poker-vm#2650).
+     */
+    static findBestOmahaHand(holeCards: Card[], communityCards: Card[]): HandEvaluation;
+    /**
+     * Best hand for a variant from hole cards and a full 5-card board.
+     */
+    private static bestHandForVariant;
     /**
      * Evaluate a hand with any number of cards (2-7)
      * This is useful for showing hand strength during all betting rounds
@@ -46154,12 +46164,14 @@ declare class PokerSolver {
     static calculateWinPercentages(handA: Card[], handB: Card[], communityCards?: Card[], simulations?: number): [number, number, number];
     /**
      * Calculate win percentages for multiple players (2+) using Monte Carlo simulation
-     * @param hands Array of hole cards for each player (each must have exactly 2 cards)
+     * @param hands Array of hole cards for each player (2 each for Hold'em, 4 for Omaha)
      * @param communityCards Current community cards (0-5 cards)
      * @param simulations Number of simulations to run (default: 10000)
+     * @param variant The table's variant; omitted = Texas Hold'em. Omaha hands are
+     *   scored with the two-plus-three rule (ui#769).
      * @returns Object containing win percentages for each player and overall tie percentage
      */
-    static calculateMultiPlayerEquity(hands: Card[][], communityCards?: Card[], simulations?: number): {
+    static calculateMultiPlayerEquity(hands: Card[][], communityCards?: Card[], simulations?: number, variant?: GameVariant): {
         winPercentages: number[];
         tiePercentage: number;
     };

package/dist/index.esm.js

@@ -56772,6 +56772,41 @@ class PokerSolver {
         }
         return bestHand;
     }
+    /**
+     * Find the best Omaha hand: EXACTLY 2 of the 4 hole cards and EXACTLY 3 of
+     * the 5 board cards — C(4,2) x C(5,3) = 60 candidates, ranked like Hold'em.
+     * Mirrors the engine's FindBestOmahaHand (poker-vm#2650).
+     */
+    static findBestOmahaHand(holeCards, communityCards) {
+        if (holeCards.length !== 4) {
+            throw new Error("Omaha requires exactly 4 hole cards");
+        }
+        if (communityCards.length !== 5) {
+            throw new Error("Omaha requires exactly 5 community cards");
+        }
+        let bestHand = null;
+        for (const pair of this.getCombinationsFlexible(holeCards, 2)) {
+            for (const triple of this.getCombinationsFlexible(communityCards, 3)) {
+                const evaluation = this.evaluateHand([...pair, ...triple]);
+                if (!bestHand || this.compareHands(evaluation, bestHand) > 0) {
+                    bestHand = evaluation;
+                }
+            }
+        }
+        if (!bestHand) {
+            throw new Error("Failed to evaluate hand");
+        }
+        return bestHand;
+    }
+    /**
+     * Best hand for a variant from hole cards and a full 5-card board.
+     */
+    static bestHandForVariant(variant, holeCards, communityCards) {
+        if (variant === GameVariant.OMAHA) {
+            return this.findBestOmahaHand(holeCards, communityCards);
+        }
+        return this.findBestHand([...holeCards, ...communityCards]);
+    }
     /**
      * Evaluate a hand with any number of cards (2-7)
      * This is useful for showing hand strength during all betting rounds
@@ -57166,12 +57201,14 @@ class PokerSolver {
     }
     /**
      * Calculate win percentages for multiple players (2+) using Monte Carlo simulation
-     * @param hands Array of hole cards for each player (each must have exactly 2 cards)
+     * @param hands Array of hole cards for each player (2 each for Hold'em, 4 for Omaha)
      * @param communityCards Current community cards (0-5 cards)
      * @param simulations Number of simulations to run (default: 10000)
+     * @param variant The table's variant; omitted = Texas Hold'em. Omaha hands are
+     *   scored with the two-plus-three rule (ui#769).
      * @returns Object containing win percentages for each player and overall tie percentage
      */
-    static calculateMultiPlayerEquity(hands, communityCards = [], simulations = 10000) {
+    static calculateMultiPlayerEquity(hands, communityCards = [], simulations = 10000, variant) {
         // Validate inputs
         if (hands.length < 2) {
             throw new Error("Need at least 2 hands to calculate equity");
@@ -57179,9 +57216,10 @@ class PokerSolver {
         if (hands.length > 10) {
             throw new Error("Maximum 10 hands supported");
         }
+        const holeCount = holeCardsPerPlayer(variant);
         for (let i = 0; i < hands.length; i++) {
-            if (hands[i].length !== 2) {
-                throw new Error(`Hand ${i} must have exactly 2 cards`);
+            if (hands[i].length !== holeCount) {
+                throw new Error(`Hand ${i} must have exactly ${holeCount} cards`);
             }
         }
         if (communityCards.length > 5) {
@@ -57208,10 +57246,7 @@ class PokerSolver {
             // Deal remaining community cards
             const fullCommunityCards = [...communityCards, ...shuffledDeck.slice(0, cardsNeeded)];
             // Evaluate all hands
-            const evaluations = hands.map(hand => {
-                const fullHand = [...hand, ...fullCommunityCards];
-                return this.findBestHand(fullHand);
-            });
+            const evaluations = hands.map(hand => this.bestHandForVariant(variant, hand, fullCommunityCards));
             // Find winners using existing findWinners method
             const winnerIndices = this.findWinners(evaluations);
             // Update win counters