two-to-seven-triple-draw

Poker hand solver. Supports:

solving the best hand from up to nine cards.
solving hands from single array input.
solving hands from table and hand card array inputs when N cards from the hand array must be used to form the hand.
comparing hands.
finding the best hand from given inputs. Similarly than Math.max(...).

Installation

npm i two-to-seven-triple-draw

Usage example

Hand = require('two-to-seven-triple-draw').Hand;
Card = require('two-to-seven-triple-draw').Card;

// Solve five card hand
const acequads = Hand.solve(
    [0, 13, 26, 39, 2].map(i => new Card(i))
);

// Solve Omaha hold em hand
const fullhouse = Hand.solveHoldEm(
    [0, 13, 26, 39, 2].map(i => new Card(i)),
    [25, 38, 11, 24].map(i => new Card(i)),
    2
);

// Get best hand
console.log(Hand.max(acequads, fullhouse).toString());

Documentation

This package provides three classes: Card, Deck and Hand. Card class implements logic for comparing and handling cards, which are passed around as Cards. Deck class provides an implementation to generate shuffled or unshuffled array of cards. Hand class implements logit for comparing and solving poker hands, which are created from arrays of integers.

All of the classed provide a static method fromJSON(...) which allows regenerating an instance of a respective class.

Card

Card provides getters for the suit and value of the card as well as static methods Card.getSuit(num), Card.getValue(num), and Card.compare(cardA, cardB). The Card.compare(...) method can be used to sort cards from high to low.

Cards are passed around as Cards. The suit of the cards is defined as Math.floor(num/13) % 4. The output integer maps to card suit as:

Integer	Suit
0	♥ Hearts
1	♠ Spades
2	♦ Diamonds
3	♣ Clubs

The value of the card is defined as num % 13 || low_ace ? 0 : 13. This results to value being represented as one smaller than it would be in an actual playing card. Aces are high by default.

Deck

Deck provides a pop method to get the next available card as a Card object, popN(n) method to get multiple cards at a time, cardsRemaining getter to check number of cards left in the Deck, and methods to shuffle as well as to check if the Deck is shuffled.

Hand

Hand provides Hand.solve(cards, num=5), Hand.solveHoldEm(table_cards, hand_cards, must_use=0), Hand.compare(a, b), and Hand.max([hand1[, hand2[, ...]]]) functions to solve and compare poker hands. Hand.solveHoldEm(...) is a helper function to support games where N number of cards from players hand cards must be used, such as Omaha hold em. Hand is passed in to the solver as a array of Cards. Solver returns object with fields for uuid, rank of the hand and cards included in the hand. For example, ace to five straight-flush would result to:

{
    "uuid": "2d82f594-579b-4dbe-ae06-187c66229734",
    "rank": 40,
    "cards": [
        {"num":4}, {"num":3}, {"num":2}, {"num":1}, {"num":0}
    ]
}

where the number for hand rank is the one defined in Hand.Rank:

Number	Hand
45	Five of a kind
40	Straight flush
35	Four of a kind
30	Full house
25	Flush
20	Straight
15	Three of a kind
10	Two pairs
5	Pair
0	High

The Hand.compare(...) function takes in two output objects from Hand.solve(...) function and returns a value, that when passed to Array.prototype.sort(...) would sort the array from the best to the worst hand. The Hand.max(...) function return the best of the input hands and is used similarly to Math.max(...).

kangasta / two-to-seven-triple-draw Goto Github PK