Deuces Wild Hand Evaluator

The source code provided on this page is for the class DWEvaluator that takes as input a five card hand and returns a value representing the hand rank (eg natural royal, four deuces, five of a kind) for the game of Deuces Wild video poker. See example.cpp in the source code for usage of this class.

Individual cards are represented by an integer between 0 and 51 according to the formula:

• Card = (13 * Suit) + Rank

Source Code

The below source code represents 3 files:

• example.cpp - Very simple example program
• DWEvaluator.h - Class definition
• DWEvaluator.cpp - Class functions

/* *******************************************
   ****          example.cpp              ****
   **** Should output:                    ****
   *******************************************
   ****   AS KS QS JS TS Evaluation = 10  ****
   ****   2C 2D 2H 2S KD Evaluation = 9   ****
   ****   2D JH 2H KH AH Evaluation = 8   ****
   ****   7D 7H 2C 2H 2S Evaluation = 7   ****
   ****   AC 2C 3C 4C 5C Evaluation = 6   ****
   ****   5C 5D 5H 5S JS Evaluation = 5   ****
   ****   JS JD JH 8S 8C Evaluation = 4   ****
   ****   AH QH TH 4H 3H Evaluation = 3   ****
   ****   8C 9D TS JH QD Evaluation = 2   ****
   ****   AS AC AD JS TS Evaluation = 1   ****
   ****   JD JC QS 3C TS Evaluation = 0   ****
   ******************************************* */

#include <stdio.h>
#include "DWEvaluator.h"

void printHand(int *hand)
{
	char rank[] = "23456789TJQKA";
	char suit[] = "CDHS";
	for (int i = 0; i < 5; i++)
	{
		int card = hand[i];
		printf("%c%c ", rank[card % 13], suit[card / 13]);
	}
}

int main (int argc, char *argv[])
{
	DWEvaluator evaluator;
	int hands[11][5] = { 
		{51,50,49,48,47}, //AS,KS,QS,JS,TS = Natural Royal
		{ 0,13,26,39,24}, //2C,2D,2H,2S,KD = Four Deuces
		{13,35,26,37,38}, //2D,JH,2H,KH,AH = Wild Royal
		{18,31, 0,26,39}, //5D,5H,2C,2H,2S = Five of a Kind
		{12, 0, 1, 2, 3}, //AC,2C,3C,4C,5C = Straight Flush
		{ 3,16,29,42,48}, //5C,5D,5H,5S,JS = Four of a Kind
		{48,22,35,45, 6}, //JS,JD,JH,8S,8C = Full House
		{38,36,34,28,27}, //AH,QH,TH,4H,3H = Flush
		{ 6,20,47,35,23}, //8C,9D,TS,JH,QD = Straight
		{51,12,25,48,47}, //AS,AC,AD,JS,TS = Three of a Kind
		{22, 9,49, 1,47}, //JD,JC,QS,3C,TS = Nothing
	};
	for (int i = 0; i < 11; i++)
	{
		printHand(hands[i]);
		printf("Evaluation = %d\n", evaluator.evaluate(hands[i]));
	}
}

/* *******************************************
   ****       DWEvaluator.h               ****
   ******************************************* */
#pragma once

const int NATURAL_ROYAL		= 10;
const int FOUR_DEUCES		= 9;
const int WILD_ROYAL		= 8;
const int FIVE_KIND		= 7;
const int STRAIGHT_FLUSH	= 6;
const int FOUR_KIND		= 5;
const int FULL_HOUSE		= 4;
const int FLUSH			= 3;
const int STRAIGHT		= 2;
const int THREE_KIND		= 1;
const int NOTHING		= 0;

class DWEvaluator
{
public:
	DWEvaluator(void);
	~DWEvaluator(void);

	int evaluate(int *);
	int evaluate(void);
		
private:
	int deuceNum;
	int rankHash[4];
	
	int straightData[8192][4];
	int bitCount[8192];
	int *cardData1[52];
	int cardData2[52];
};

/* *******************************************
   ****       DWEvaluator.cpp             ****
   ******************************************* */

#include "DWEvaluator.h"

DWEvaluator::DWEvaluator(void)
{
	int straights[10] = {4111,31,62,124,248,496,992,1984,3968,7936};
	for (int i = 0; i < 8192; i++)
	{
		bitCount[i] = 0;
		for (int j = 0; j < 13; j++)
		{
			if ((i & (1 << j)) > 0)
			{
				bitCount[i]++;
			}
		}
	}
	for (int i = 0; i < 8192; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			straightData[i][j] = 0;
			for (int k = 0; k < 10; k++)
			{
				if (bitCount[straights[k] & i] + j == 5)
				{
					straightData[i][j] = k + 1;
				}
			}
		}
	}
	for (int i = 0; i < 52; i++)
	{
		cardData1[i] = &(rankHash[i / 13]);
		cardData2[i] = 1 << (i % 13);
	}
}

DWEvaluator::~DWEvaluator(void)
{
}

int DWEvaluator::evaluate(int *hand)
{
	deuceNum = 0;
	rankHash[0] = 0;
	rankHash[1] = 0;
	rankHash[2] = 0;
	rankHash[3] = 0;
	for (int i = 0; i < 5; i++)
	{
		int hash = cardData2[hand[i]];
		if (hash == 1)
		{
			deuceNum++;
		}
		else
		{
			*cardData1[hand[i]] |= hash;
		}
	}
	return evaluate();
}

int DWEvaluator::evaluate(void)
{
	//Four Deuces
	if (deuceNum == 4)
	{
		return FOUR_DEUCES;
	}
	//Royal Flushes
	for (int i = 0; i < 4; i++)
	{
		if (straightData[rankHash[i]][deuceNum] == 10)
		{
			if (deuceNum == 0)
			{
				return NATURAL_ROYAL;
			}
			else
			{
				return WILD_ROYAL;
			}
		}
	}
	//Five Kind
	int hash1 = rankHash[0] | rankHash[1] | rankHash[2] | rankHash[3];
	if (bitCount[hash1] == 1)
	{
		return FIVE_KIND;
	}
	//Straight Flush
	for (int i = 0; i < 4; i++)
	{
		if (straightData[rankHash[i]][deuceNum])
		{
			return STRAIGHT_FLUSH;
		}
	}
	//Four Kind
	int hash4 = rankHash[0] & rankHash[1] & rankHash[2] & rankHash[3];
	int hash3 = (rankHash[0] & rankHash[1] & rankHash[2]) | (rankHash[0] & rankHash[1] & rankHash[3]) 
			| (rankHash[0] & rankHash[2] & rankHash[3]) | (rankHash[1] & rankHash[2] & rankHash[3]);
	int hash2 = (rankHash[0] & rankHash[1]) | (rankHash[0] & rankHash[2]) | (rankHash[0] & rankHash[3]) 
			| (rankHash[1] & rankHash[2]) | (rankHash[1] & rankHash[3]) | (rankHash[2] & rankHash[3]);
	if (deuceNum == 3 || (deuceNum == 2 && hash2) || (deuceNum == 1 && hash3) || (deuceNum == 0 && hash4))
	{
		return FOUR_KIND;
	}
	//Full House
	if ((deuceNum == 1 && bitCount[hash2] == 2) || (deuceNum == 0 && hash3 && bitCount[hash2] == 2))
	{
		return FULL_HOUSE;
	}
	//Flush
	for (int i = 0; i < 4; i++)
	{
		if (bitCount[rankHash[i]] + deuceNum == 5)
		{
			return FLUSH;
		}
	}
	//Straight
	if (straightData[hash1][deuceNum])
	{
		return STRAIGHT;
	}
	//Three Kind
	if (deuceNum == 2 || (deuceNum == 1 && hash2) || (deuceNum == 0 && hash3))
	{
		return THREE_KIND;
	}
	//Nothing
	return NOTHING;
}