Custom Video Poker Game

This page lets you create your own video poker game. To define the hands, go to the Paytable section and click Edit next to an existing hand to change it, or an empty hand to add one. You can enter up to 15 different paying hands.

Deck Simplification

Hand Identification Codes

Because virtually any type of hand can be defined as a winner, numeric codes are used to describe each type of paying hand. The first four bits of each code identifies the Core Hand Type. The following table illustrates the possible values for the Core Hand Type:

Description	Value
Nothing	0
One Pair	1
Two Pair	2
Three of a Kind	3
Straight	4
Flush	5
Full House	6
Four of a Kind	7
Straight Flush (incl. Royal Flush)	8

In addition to the Core Hand Type value above, there are two sets of 13 bits ("Major" and "Minor"). Each bit refers to one of the 13 card ranks (Deuce through Ace) and can be either zero or one, depending on whether or not the card is allowed in each specific context. The context changes depending on the Core Hand Type, as illustrated in the following table:

Core Hand Type	Major	Minor
Nothing	Not Used	Not Used
One Pair	Pair Rank	Not Used
Two Pair	Not Used	Not Used
Three of a Kind	Trips Rank	Not Used
Straight	Not Used	Not Used
Flush	Not Used	Not Used
Full House	Not Used	Not Used
Four of a Kind	Quads Rank	Kicker Rank
Straight Flush	High Card	Not Used

Each 13-bit chunk is then combined with the Core Hand Type to produce a final HandCode value using the following formula:

HandCode[x] = (CoreHandType << 26) + (Major << 13) + Minor;

Hand Scoring Code

The HandCode[] array contains the numeric codes described above. HandCode[0] corresponds to a losing hand, and all other HandCode values correspond to the winning hand types defined in the Paytable section.

int GetHandType(int C1, int C2, int C3, int C4, int C5)
{
    int Code = 0, Hand = 0, Flags1 = 0, Flags2 = 0, x = 0;
    int HC, F1, F2;
    int FinalHand = 0;

    int R1 = Rank[C1],
        R2 = Rank[C2],
        R3 = Rank[C3],
        R4 = Rank[C4],
        R5 = Rank[C5];

    int S1 = Suit[C1],
        S2 = Suit[C2],
        S3 = Suit[C3],
        S4 = Suit[C4],
        S5 = Suit[C5];

    bool Flush =

        (S1 == S2) &&
        (S2 == S3) &&
        (S3 == S4) &&
        (S4 == S5);

    if (R1 > R2) { R1 ^= R2; R2 ^= R1; R1 ^= R2; }
    if (R1 > R3) { R1 ^= R3; R3 ^= R1; R1 ^= R3; }
    if (R1 > R4) { R1 ^= R4; R4 ^= R1; R1 ^= R4; }
    if (R1 > R5) { R1 ^= R5; R5 ^= R1; R1 ^= R5; }
    if (R2 > R3) { R2 ^= R3; R3 ^= R2; R2 ^= R3; }
    if (R2 > R4) { R2 ^= R4; R4 ^= R2; R2 ^= R4; }
    if (R2 > R5) { R2 ^= R5; R5 ^= R2; R2 ^= R5; }
    if (R3 > R4) { R3 ^= R4; R4 ^= R3; R3 ^= R4; }
    if (R3 > R5) { R3 ^= R5; R5 ^= R3; R3 ^= R5; }
    if (R4 > R5) { R4 ^= R5; R5 ^= R4; R4 ^= R5; }

    if (Flush)
    {
        if ((R4 == 3) && (R5 == 12))
        {
            Hand = 8; Flags1 = (1 << R4);     // Straight Flush, Five High
        }

        else if ((R5 - R1) == 4)
        {
            Hand = 8; Flags1 = (1 << R5);     // Straight Flush, Six through Ace High
        }

        else
        {
            Hand = 5;                               // Flush
        }
    }

    else
    {
        if ((R1 == R2) && (R2 == R3) && (R3 == R4))
        {
            Hand = 7; Flags1 = (1 << R3); Flags2 = (1 << R5);   // Four of a Kind, QQQQk
        }

        else if ((R2 == R3) && (R3 == R4) && (R4 == R5))
        {
            Hand = 7; Flags1 = (1 << R3); Flags2 = (1 << R1);   // Four of a Kind, kQQQQ
        }

        else if ((R1 == R2) && (R2 == R3) && (R4 == R5))    // Full House, AAAbb
        {
            Hand = 6;
        }

        else if ((R1 == R2) && (R3 == R4) && (R4 == R5))    // Full House, aaBBB
        {
            Hand = 6;
        }

        else if ((R1 == (R2 - 1)) &&
                 (R2 == (R3 - 1)) &&
                 (R3 == (R4 - 1)) &&
                ((R4 == (R5 - 1)) || ((R1 == 0) && (R5 == 12))))
        {
            Hand = 4;                                                       // Straight
        }

        else if (((R1 == R2) && (R2 == R3)) ||
                 ((R2 == R3) && (R3 == R4)) ||
                 ((R3 == R4) && (R4 == R5)))
        {
            Hand = 3; Flags1 = (1 << R3);                             // Three of a Kind
        }

        else if (((R1 == R2) && (R3 == R4)) ||
                 ((R1 == R2) && (R4 == R5)) ||
                 ((R2 == R3) && (R4 == R5)))
        {
            Hand = 2;                                                       // Two Pair
        }
        else if ((R1 == R2) || (R2 == R3))
        {
            Hand = 1; Flags1 = (1 << R2);                             // One Pair, AAbcd or aBBcd
        }
        else if ((R3 == R4) || (R4 == R5))
        {
            Hand = 1; Flags1 = (1 << R4);                             // One Pair, abCCd or abcDD
        }
    }

    for (x = NumHands - 1; x >= 1; x--)
    {
        HC = HandCode[x] >> 26;             // Core Type
        F1 = HandCode[x] & 16383;           // Low Flags
        F2 = (HandCode[x] >> 13) & 16383;   // High Flags

        if ((HC == Hand) && ((F1 & Flags1) == Flags1) && ((F2 & Flags2) == Flags2))
        {
            FinalHand = x; break;
        }
    }

    return FinalHand;
}