Deuces Wild (Grand Virtual Progressive)

This game is the progressive jackpot version of Deuces Wild which is available at online casinos that use Grand Virtual software. To win the jackpot you have to be dealt a Sequential Royal Flush in any suit (both directions count). The strategy is the same regardless of the amount of the jackpot, because there is no strategy involved in the deal portion of a hand.

The odds of winning the jackpot are 1 in 38,984,400. The base return of the game when the jackpot resets to 25,000 credits is 97.5899%. Every additional 5,000 coins in the jackpot adds 0.002565% to the theoretical return of the game. The break-even point is when the jackpot reaches 4,722,798 coins (944,559.6 times the bet). I would say that it is very difficult to win the jackpot, which means it would probably grow for a long time before being won. Yet, on the other hand, I doubt the jackpot would ever reach the break-even point before being won. Because the game only returns 97.5791% without the jackpot, I would recommend avoiding it unless you feel extremely lucky. If you want to play Deuces Wild at a Grand Virtual casino, you should play their regular version which features the NSUD paytable that returns 99.7283%.

Deck Simplification

Hand Scoring Code

int WildRank = 0;

int GetHandType(int C1, int C2, int C3, int C4, int C5)
{
    int Hand = 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 = false;

    if (R1 > R2) { R1 ^= R2; R2 ^= R1; R1 ^= R2; S1 ^= S2; S2 ^= S1; S1 ^= S2; }
    if (R1 > R3) { R1 ^= R3; R3 ^= R1; R1 ^= R3; S1 ^= S3; S3 ^= S1; S1 ^= S3; }
    if (R1 > R4) { R1 ^= R4; R4 ^= R1; R1 ^= R4; S1 ^= S4; S4 ^= S1; S1 ^= S4; }
    if (R1 > R5) { R1 ^= R5; R5 ^= R1; R1 ^= R5; S1 ^= S5; S5 ^= S1; S1 ^= S5; }
    if (R2 > R3) { R2 ^= R3; R3 ^= R2; R2 ^= R3; S2 ^= S3; S3 ^= S2; S2 ^= S3; }
    if (R2 > R4) { R2 ^= R4; R4 ^= R2; R2 ^= R4; S2 ^= S4; S4 ^= S2; S2 ^= S4; }
    if (R2 > R5) { R2 ^= R5; R5 ^= R2; R2 ^= R5; S2 ^= S5; S5 ^= S2; S2 ^= S5; }
    if (R3 > R4) { R3 ^= R4; R4 ^= R3; R3 ^= R4; S3 ^= S4; S4 ^= S3; S3 ^= S4; }
    if (R3 > R5) { R3 ^= R5; R5 ^= R3; R3 ^= R5; S3 ^= S5; S5 ^= S3; S3 ^= S5; }
    if (R4 > R5) { R4 ^= R5; R5 ^= R4; R4 ^= R5; S4 ^= S5; S5 ^= S4; S4 ^= S5; }

    if ((S1 == S2) &&
        (S2 == S3) &&
        (S3 == S4) &&
        (S4 == S5) &&
        (R1 == 08) &&
        (R2 == 09) &&
        (R3 == 10) &&
        (R4 == 11) &&
        (R5 == 12))
    {
        Hand = 10;     // Natural Royal Flush
    }
    else
    {
        int Wilds = (R1 == WildRank ? 1 : 0)
                  + (R2 == WildRank ? 1 : 0)
                  + (R3 == WildRank ? 1 : 0)
                  + (R4 == WildRank ? 1 : 0)
                  + (R5 == WildRank ? 1 : 0);

        switch (Wilds)
        {
            case 1:

                     if (R1 == WildRank) { }

                else if (R2 == WildRank) { R1 ^= R2; R2 ^= R1; R1 ^= R2; S1 ^= S2; S2 ^= S1; S1 ^= S2; }

                else if (R3 == WildRank) { R1 ^= R3; R3 ^= R1; R1 ^= R3; S1 ^= S3; S3 ^= S1; S1 ^= S3;
                                           R2 ^= R3; R3 ^= R2; R2 ^= R3; S2 ^= S3; S3 ^= S2; S2 ^= S3; }

                else if (R4 == WildRank) { R1 ^= R4; R4 ^= R1; R1 ^= R4; S1 ^= S4; S4 ^= S1; S1 ^= S4;
                                           R2 ^= R4; R4 ^= R2; R2 ^= R4; S2 ^= S4; S4 ^= S2; S2 ^= S4;
                                           R3 ^= R4; R4 ^= R3; R3 ^= R4; S3 ^= S4; S4 ^= S3; S3 ^= S4; }

                else if (R5 == WildRank) { R1 ^= R5; R5 ^= R1; R1 ^= R5; S1 ^= S5; S5 ^= S1; S1 ^= S5;
                                           R2 ^= R5; R5 ^= R2; R2 ^= R5; S2 ^= S5; S5 ^= S2; S2 ^= S5;
                                           R3 ^= R5; R5 ^= R3; R3 ^= R5; S3 ^= S5; S5 ^= S3; S3 ^= S5;
                                           R4 ^= R5; R5 ^= R4; R4 ^= R5; S4 ^= S5; S5 ^= S4; S4 ^= S5; }
                break;

            case 2:

                     if (R1 == WildRank) { }

                else if (R2 == WildRank) { R1 ^= R3; R3 ^= R1; R1 ^= R3; S1 ^= S3; S3 ^= S1; S1 ^= S3; }

                else if (R3 == WildRank) { R1 ^= R3; R3 ^= R1; R1 ^= R3; S1 ^= S3; S3 ^= S1; S1 ^= S3;
                                           R2 ^= R4; R4 ^= R2; R2 ^= R4; S2 ^= S4; S4 ^= S2; S2 ^= S4; }

                else if (R4 == WildRank) { R3 ^= R5; R5 ^= R3; R3 ^= R5; S3 ^= S5; S5 ^= S3; S3 ^= S5;
                                           R1 ^= R3; R3 ^= R1; R1 ^= R3; S1 ^= S3; S3 ^= S1; S1 ^= S3;
                                           R2 ^= R4; R4 ^= R2; R2 ^= R4; S2 ^= S4; S4 ^= S2; S2 ^= S4; }

                break;

            case 3:

                     if (R1 == WildRank) { }

                else if (R2 == WildRank) { R1 ^= R4; R4 ^= R1; R1 ^= R4; S1 ^= S4; S4 ^= S1; S1 ^= S4; }

                else if (R3 == WildRank) { R1 ^= R4; R4 ^= R1; R1 ^= R4; S1 ^= S4; S4 ^= S1; S1 ^= S4;
                                           R2 ^= R5; R5 ^= R2; R2 ^= R5; S2 ^= S5; S5 ^= S2; S2 ^= S5; }

                break;

            case 4:

                     if (R1 == WildRank) { }

                else if (R2 == WildRank) { R1 ^= R5; R5 ^= R1; R1 ^= R5; S1 ^= S5; S5 ^= S1; S1 ^= S5; }

                break;
        }

        switch (Wilds)
        {
            case 0:

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

                if (Flush)
                {

                    if (R1 == 8)
                    {
                        Hand = 10;          // Natural Royal Flush
                    }

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

                    else
                    {
                        Hand = 3;           // Flush
                    }
                }

                else
                {
                    if ((R2 == R3) && (R3 == R4) && ((R1 == R2) || (R4 == R5)))
                    {
                        Hand = 5;           // Four of a Kind
                    }

                    else if ((R1 == R2) && (R4 == R5) && ((R2 == R3) || (R3 == R4)))
                    {
                        Hand = 4;           // Full House
                    }

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

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

                break;

            case 1:

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

                if (Flush)
                {
                    if (R2 >= 8)
                    {
                        Hand = 8;                // Wild Royal Flush
                    }
                    else if (((R5 - R2) <= 4) || ((R5 == 12) && (R4 <= 3)))
                    {
                        Hand = 6;                // Straight Flush
                    }
                    else
                    {
                        Hand = 3;                // Flush
                    }
                }

                else
                {
                    if ((R2 == R3) && (R3 == R4) && (R4 == R5))
                    {
                        Hand = 7;                // Five of a Kind
                    }
                    else if (((R2 == R3) && (R3 == R4)) || ((R3 == R4) && (R4 == R5)))
                    {
                        Hand = 5;                // Four of a Kind
                    }
                    else if ((R2 == R3) && (R4 == R5))
                    {
                        Hand = 4;                // Full House
                    }
                    else if ((((R5 - R2) <= 4) || ((R5 == 12) && (R4 <= 3))) &&
                            (R2 != R3) && (R3 != R4) && (R4 != R5))
                    {
                        Hand = 2;                // Straight
                    }
                    else if ((R2 == R3) || (R3 == R4) || (R4 == R5))
                    {
                        Hand = 1;                // Three of a Kind
                    }
                }

                break;

            case 2:

                Flush = (S3 == S4) && (S4 == S5);

                if (Flush)
                {
                    if (R3 >= 8)
                    {
                        Hand = 8;                // Wild Royal Flush
                    }
                    else if (((R5 - R3) <= 4) || ((R5 == 12) && (R4 <= 3)))
                    {
                        Hand = 6;                // Straight Flush
                    }
                    else
                    {
                        Hand = 3;                // Flush
                    }
                }
                else
                {
                    if ((R3 == R4) && (R4 == R5))
                    {
                        Hand = 7;                // Five of a Kind
                    }
                    else if ((R3 == R4) || (R4 == R5))
                    {
                        Hand = 5;                // Four of a Kind
                    }
                    else if ((((R5 - R3) <= 4) || ((R5 == 12) && (R4 <= 3))) &&
                            (R3 != R4) && (R4 != R5))
                    {
                        Hand = 2;                // Straight
                    }
                    else
                    {
                        Hand = 1;                // Three of a Kind
                    }
                }

                break;

            case 3:

                Flush = (S4 == S5);

                if (Flush)
                {
                    if (R4 >= 8)
                    {
                        Hand = 8;                // Wild Royal Flush
                    }
                    else if (((R5 - R4) <= 4) || ((R5 == 12) && (R4 <= 3)))
                    {
                        Hand = 6;                // Straight Flush
                    }
                    else
                    {
                        Hand = 5;                // Four of a Kind
                    }
                }
                else
                {
                    if (R4 == R5)
                    {
                        Hand = 7;                // Five of a Kind
                    }
                    else
                    {
                        Hand = 5;                // Four of a Kind
                    }
                }

                break;

            case 4:

                Flush = true;
                Hand = 9;                      // Four Wilds
                break;
        }
    }

    return Hand;
}

Sequential Royal Flush on the Deal

Because this game has a jackpot for a Sequential Royal Flush on the deal, some adjustments are necessary to accurately analyze the game. Unlike regular Sequential Royal Flush games, there is no strategy involved because the Sequential Royal Flush must occur on the deal. Therefore, we only need to multiply the number of hands that are possible on the deal by 120, and do not need to do the same for the number of hands possible on the draw.

For the majority of starting hands, the number of permutations is calculated by simply multiplying by 120. When the starting hand is a Royal Flush, it is necessary to multiply by 120 but split it into two types - a Sequential Royal Flush or a Non-Sequential Royal Flush. Since both directions count, there are 2 ways to be dealt a Sequential Royal Flush, and 118 ways to be dealt a Non-Sequential Royal Flush. Therefore, the average value is calculated by multiplying the jackpot amount by 2⁄120 and the regular Royal Flush payout by 118⁄120.

No other modifications are necessary. The strategy for the game always remains the same regardless of how large the jackpot is.