/**************************************
Determine whether a player has a Straight
Flush. A Straight Flush is any straight with
all five cards of the same suit. -Alicia
**************************************/
int isStraightFlush(struct player gamer, int numberOfCards)
{
if (isStraight(gamer, numberOfCards) && isFlush(gamer, numberOfCards))
return STRAIGHT_FLUSH;
else
return NONE;
}
int PokerHandEvaluator::evaluate(Hand hand){
//logic and some code taken from here: http://www.mathcs.emory.edu/~cheung/Courses/170/Syllabus/10/pokerValue.html
std::vector<Card*> cards = hand.getCards();
std::sort(cards.begin(), cards.end(), Compare());
if (isFlush(cards) && isStraight(cards)) return valueStraightFlush(cards);
else if (is4s(cards)) return valueFourOfAKind(cards);
else if (isFullHouse(cards)) return valueFullHouse(cards);
else if (isFlush(cards)) return valueFlush(cards);
else if (isStraight(cards)) return valueStraight(cards);
else if (is3s(cards)) return valueSet(cards);
else if (is22s(cards)) return valueTwoPairs(cards);
else if (is2s(cards)) return valueOnePair(cards);
else return valueHighCard(cards); // Lowest Poker hand;
}
/* Adrian Hernandez */
cardrank isStraightFlush(Card *cards[]){
cardrank result = NIL;
cardrank isStraightResult = isStraight(cards);
cardrank isFlushResult = isFlush(cards);
if ((isStraightResult != NIL) && (isFlushResult != NIL)) {
result = isStraightResult;
}
return result;
}
// TODO //
Hand* Util::determineHandType(std::vector<Card*>& p_cards)
{
determineDuplicateCards(p_cards);
Hand * newHand = nullptr;
uint handType = HIGHEST_CARD;
if (isRoyalFlush(p_cards))
{
newHand = new NonRepeatedHand(ROYAL_FLUSH, p_cards);
}
else if (isStraightFlush(p_cards))
{
newHand = new NonRepeatedHand(STRAIGHT_FLUSH, p_cards);
}
else if (isFourOfAKind())
{
newHand = new RepeatedHand(FOUR_OF_A_KIND, p_cards, m_occurences, m_occurencesVector);
}
else if (isFullHouse())
{
newHand = new RepeatedHand(FULL_HOUSE, p_cards, m_occurences, m_occurencesVector);
}
else if (isFlush(p_cards))
{
newHand = new NonRepeatedHand(FLUSH, p_cards);
}
else if (isStraight(p_cards))
{
newHand = new NonRepeatedHand(STRAIGHT, p_cards);
}
else if (isThreeOfAKind())
{
newHand = new RepeatedHand(THREE_OF_A_KIND, p_cards, m_occurences, m_occurencesVector);
}
else if (isTwoPairs())
{
newHand = new RepeatedHand(TWO_PAIRS, p_cards, m_occurences, m_occurencesVector);
}
else if (isOnePair())
{
newHand = new RepeatedHand(ONE_PAIR, p_cards, m_occurences, m_occurencesVector);
}
else
{
newHand = new NonRepeatedHand(HIGHEST_CARD, p_cards);
}
m_occurences.clear();
m_occurencesVector.clear();
return newHand;
}
uint32_t getHandValue(uint8_t * const hand) {
orderHand(hand);
if(isStraightFlush(hand)) return 8;
if(isXOfKind(hand,4) ) return 7;
if(isFullHouse(hand) ) return 6;
if(isFlush(hand) ) return 5;
if(isStraight(hand) ) return 4;
if(isXOfKind(hand,3) ) return 3;
if(isTwoPair(hand) ) return 2;
if(isXOfKind(hand,2) ) return 1;
return 0;
}
/* Adrian Hernandez */
void rankHand(Hand *hand){
cardrank tieBreaker;
handrank hrank = HIGH_CARD;
if ((tieBreaker = isStraightFlush(hand -> cards)) != NIL) {
hrank = STRAIGHT_FLUSH;
}
else if ((tieBreaker = isFourKind(hand -> cards)) != NIL){
hrank = FOUR_KIND;
}
else if((tieBreaker = isFullHouse(hand -> cards)) != NIL){
hrank = FULL_HOUSE;
}
else if((tieBreaker = isFlush(hand -> cards)) != NIL){
hrank = FLUSH;
}
else if((tieBreaker = isStraight(hand -> cards)) != NIL){
hrank = STRAIGHT;
}
else if((tieBreaker = isThreeOfAKind(hand -> cards)) != NIL){
hrank = THREE_KIND;
}
else if((tieBreaker = isTwoPair(hand -> cards)) != NIL){
hrank = TWO_PAIR;
}
else if((tieBreaker = isOnePair(hand -> cards, NIL)) != NIL){
hrank = ONE_PAIR;
}
else {
/* high card */
cardrank lowCard = (hand -> cards[0]) -> rank;
cardrank highCard = (hand -> cards[POKER_HAND - 1]) -> rank;
/* since ACE could be at the beginning */
tieBreaker = max(lowCard, highCard);
}
hand -> rank = hrank;
hand -> tieBreaker = tieBreaker;
}
int score(const std::vector<std::string>& vec)
{
if (isRoyalFlush(vec))
return 900;
if (isStraightFlush(vec))
return 800 + getHighCard(vec);
if (isFourCard(vec))
return 700 + getHighCard(vec, 4);
if (isFullHouse(vec))
return 600 + getHighCard(vec, 3);
if (isFlush(vec))
return 500 + getHighCard(vec);
if (isStraight(vec))
return 400 + getHighCard(vec);
if (isThreeCard(vec))
return 300 + getHighCard(vec, 3);
if (isTwoPair(vec))
return 200 + getHighCard(vec, 2);
if (isOnePair(vec))
return 100 + getHighCard(vec, 1);
return getHighCard(vec);
}
HandType PokerHandEvaluator::evaluate(Hand hand) {
cards = hand.getCards();
if (isFlush()) {
return FLUSH;
}
if (hasFourOfKind() != NORANK) {
return FOUROFAKIND;
}
if (hasTriple() != NORANK && pairCount() >= 2) {
return HOUSE;
}
if (hasTriple() != NORANK) {
return THREEOFAKIND;
}
if (pairCount() == 2) {
return TWOPAIR;
}
if (pairCount() == 1) {
return ONEPAIR;
}
return HIGHCARD;
}
PokerHand Hand::rank() const
{
if (isRoyalFlush())
return PokerHand::ROYAL_FLUSH;
if (isStraightFlush())
return PokerHand::STRAIGHT_FLUSH;
if (isFourOfAKind())
return PokerHand::FOUR_OF_A_KIND;
if (isFullHouse())
return PokerHand::FULL_HOUSE;
if (isFlush())
return PokerHand::FLUSH;
if (isStraight())
return PokerHand::STRAIGHT;
if (isThreeOfAKind())
return PokerHand::THREE_OF_A_KIND;
if (isTwoPair())
return PokerHand::TWO_PAIR;
if (isJacksOrBetter())
return PokerHand::JACKS_OR_BETTER;
return PokerHand::NADA;
}
bool Hand::isStraightFlush() const
{
return (isStraight() && isFlush());
}
bool isStraightFlush(const std::vector<std::string>& vec)
{
if (isStraight(vec) && isFlush(vec))
return true;
return false;
}
void Poker::getCardType(std::vector<CCard> &mVecSortCards, CardType &ct)
{
if (mVecSortCards.size() != 5)
{
return;
}
ct.clear();
bool isflush = false;
bool isstraight = false;
isflush = isFlush(mVecSortCards);
isstraight = isStraight(mVecSortCards);
UInt8 mFirst = 0;
UInt8 mSecond = 0;
UInt8 mThird = 0;
UInt8 mFourth = 0;
UInt8 mScanTable[16];
UInt8 keyvalue = 0;
UInt8 type = 0;
memset(mScanTable, 0, sizeof(mScanTable));
for (size_t i = 0; i < mVecSortCards.size(); ++i)
{
if (mVecSortCards[i].m_nValue >= 3 && mVecSortCards[i].m_nValue <= 15)
{
mScanTable[mVecSortCards[i].m_nValue]++;
}
}
for (int i = 2; i < 14; ++i)
{
if (mScanTable[i] == 1)
++mFirst;
else if (mScanTable[i] == 2)
++mSecond;
else if (mScanTable[i] == 3)
++mThird;
else if (mScanTable[i] == 4)
++mFourth;
}
for (int i = 2; i < 14; ++i)
{
if (mScanTable[i] == 1)
keyvalue = i;
else if (mScanTable[i] == 2)
++mSecond;
else if (mScanTable[i] == 3)
++mThird;
else if (mScanTable[i] == 4)
++mFourth;
}
if (mVecSortCards[0].m_nValue == 14 && isflush && isstraight)
{
type = 10;
keyvalue = 14;
return;
}
else if (mVecSortCards[0].m_nValue != 14 && isflush && isstraight)
{
type = 9;
keyvalue = mVecSortCards[0].m_nValue;
return;
}
else if(mFourth == 1 && mFirst == 1)
{
type = 8;
}
else if (mThird == 1 && mSecond == 1)
{
type = 7;
}
else if (isflush)
{
type = 6;
}
else if (isstraight)
{
type = 5;
}
else if (mThird == 1 && mFirst == 2)
{
type = 4;
}
else if (mSecond == 2 && mFirst == 1)
{
type = 3;
}
else if (mSecond == 1 && mFirst == 3)
{
type = 2;
}
else if (mFirst == 5)
{
type = 1;
}
type = 0;
for (int i = 2; i < 14; ++i)
{
if (mScanTable[i] == 1 && type == 1)
{
keyvalue = i;
}
else if (mScanTable[i] == 2 && (type == 2 || type == 3) )
{
keyvalue = i;
}
else if (mScanTable[i] == 3 && (type == 4 || type == 7))
{
keyvalue = i;
break;
}
else if (mScanTable[i] == 4)
{
keyvalue = i;
}
}
}
int isStraightFlush(char* hand) { // test de la Quinte Flush
if (isStraight(hand) == 1 && isFlush(hand) == 1)
return 1;
return 0;
}
char* calculForceSymbolique(char* hand) { // création des forces symboliques
char* forceSymbolique = new char[10];
if (isStraightFlush(hand) == 1) {
sprintf(forceSymbolique, "9%c", hand[0]);
return forceSymbolique;
}
if (isQuads(hand) == 1) {
if (hand[0] == hand[2]) {
sprintf(forceSymbolique, "8%c%c", hand[0], hand[8]);
return forceSymbolique;
}
sprintf(forceSymbolique, "8%c%c", hand[2], hand[0]);
return forceSymbolique;
}
if (isFullHouse(hand) == 1) {
if (hand[0] == hand[4]) {
sprintf(forceSymbolique, "7%c%c", hand[4], hand[8]);
return forceSymbolique;
}
sprintf(forceSymbolique, "7%c%c", hand[4], hand[0]);
return forceSymbolique;
}
if (isFlush(hand) == 1) {
sprintf(forceSymbolique, "6%c%c%c%c%c", hand[0], hand[2], hand[4],
hand[6], hand[8]);
return forceSymbolique;
}
if (isStraight(hand) == 1) {
sprintf(forceSymbolique, "5%c", hand[0]);
return forceSymbolique;
}
if (isTrips(hand) == 1) {
if (hand[0] == hand[4]) {
sprintf(forceSymbolique, "4%c%c%c", hand[4], hand[6], hand[8]);
return forceSymbolique;
}
sprintf(forceSymbolique, "4%c%c%c", hand[4], hand[0], hand[2]);
return forceSymbolique;
}
if (isTwoPairs(hand) == 1) {
if (hand[0] != hand[2]) {
sprintf(forceSymbolique, "3%c%c%c", hand[2], hand[6], hand[0]);
return forceSymbolique;
} else if (hand[8] != hand[6]) {
sprintf(forceSymbolique, "3%c%c%c", hand[0], hand[4], hand[8]);
return forceSymbolique;
}
sprintf(forceSymbolique, "3%c%c%c", hand[0], hand[6], hand[4]);
return forceSymbolique;
}
if (isSinglePair(hand) == 1) {
if (hand[0] == hand[2]) {
sprintf(forceSymbolique, "2%c%c%c%c", hand[0], hand[4], hand[6],
hand[8]);
return forceSymbolique;
} else if (hand[2] == hand[4]) {
sprintf(forceSymbolique, "2%c%c%c%c", hand[2], hand[0], hand[6],
hand[8]);
return forceSymbolique;
} else if (hand[4] == hand[6]) {
sprintf(forceSymbolique, "2%c%c%c%c", hand[4], hand[0], hand[2],
hand[8]);
return forceSymbolique;
}
sprintf(forceSymbolique, "2%c%c%c%c", hand[6], hand[0], hand[2],
hand[4]);
return forceSymbolique;
}
sprintf(forceSymbolique, "1%c%c%c%c%c", hand[0], hand[2], hand[4], hand[6],
hand[8]);
/*forceSymbolique[0]='1';
forceSymbolique[1]=hand[0];
forceSymbolique[2]=hand[2];
forceSymbolique[3]=hand[4];
forceSymbolique[4]=hand[6];
forceSymbolique[5]=hand[8];
forceSymbolique[6]='\0';*/
return forceSymbolique;
}
void evaluateHand (Card *hand, int *cardRankCount, int* handScore) {
int flush, straight;
int quad[1] = {0}, triple[1] = {0}, pair[2] = {0}, single[HAND_SIZE] = {0};
flush = isFlush (hand);
straight = isStraight (cardRankCount);
getNumNOfAKind (cardRankCount, 4, quad);
getNumNOfAKind (cardRankCount, 3, triple);
getNumNOfAKind (cardRankCount, 2, pair);
getNumNOfAKind (cardRankCount, 1, single);
if (straight == 10 && flush) {
handScore[0] = ROYAL_FLUSH;
return;
}
else if (straight != 0 && flush) {
handScore[0] = STRAIGHT_FLUSH;
handScore[1] = straight;
return;
} //{8, 9} represents 9,10,J,Q,K
else if (quad[0] != 0) {
handScore[0] = FOUR_OF_A_KIND;
handScore[1] = quad[0];
handScore[2] = single[0];
return;
} //{7, E, 2} represents A,A,A,A,2
else if (triple[0] != 0 && pair[0] != 0) {
handScore[0] = FULL_HOUSE;
handScore[1] = triple[0];
handScore[2] = pair[0];
return;
} //{6, E, D} represents A,A,A,K,K
else if (flush) {
handScore[0] = FLUSH;
for (int i = 1; i < 1 + HAND_SIZE; i++) handScore[i] = single[i];
return;
} //{5, E, 6, 5, 4, 3} represents A,3,4,5,6
else if (straight) {
handScore[0] = STRAIGHT;
handScore[1] = straight;
return;
} //{4, 2} represents 2,3,4,5,6
else if (triple[0] != 0) {
handScore[0] = THREE_OF_A_KIND;
handScore[1] = triple[0];
for (int i = 0; i < 2; i++) handScore[i + 2] = single[i];
return;
} //{3, E, 7, 6} represents A,A,A,7,6
else if (pair[0] != 0 && pair[1] != 0) {
handScore[0] = TWO_PAIR;
for (int i = 0; i < 2; i++) handScore[i + 1] = pair[i];
handScore[3] = single[0];
return;
} //{2, E, D, 6} represents A,A,K,K,6
else if (pair[0] != 0) {
handScore[0] = ONE_PAIR;
handScore[1] = pair[0];
for (int i = 0; i < 3; i++) handScore[i + 2] = single[i];
return;
} //{1, E, 6, 5, 4} represents A,A,4,5,6
else {
handScore[0] = BUST;
for (int i = 0; i < HAND_SIZE; i++) handScore[i + 1] = single[i];
return;
} //{0, E, 6, 5, 4, 3} represents A,3,4,5,6
}
uint8_t isStraightFlush(uint8_t * const hand) {
return isFlush(hand) && isStraight(hand);
}
