// 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;
}
/* Adrian Hernandez */
cardrank isFullHouse(Card *cards[]){
cardrank result = NIL;
cardrank threeKindResult = isThreeOfAKind(cards);
if (threeKindResult != NIL) {
/* check if there are 2 matching cards of a different rank. */
if (isOnePair(cards, threeKindResult) != NIL){
result = threeKindResult;
}
}
return result;
}
//Function that checks for two different pair of cards. Each pair is a pair of cards with the same rank.
cardrank isTwoPair(Card *pokerHand[])
{
cardrank firstPair, secondPair, result;
firstPair = isOnePair(pokerHand, NIL); //Checks for one pair first
secondPair = NIL;
if(firstPair != NIL) //If there is a first pair then it gets ignored to check for a second pair.
{
secondPair = isOnePair(pokerHand, firstPair);
}
if((firstPair == NIL || secondPair == NIL) || (firstPair == secondPair)) //Return NIL if there is only one pair or no pairs or if both pairs have same rank.
{
result = NIL;
}
else
{
result = max(firstPair,secondPair); //Returns the largest ranked pair for tiebreaking
}
return result;
}
/* 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);
}
/* Camilo Riviere */
cardrank isStraight(Card *hand[]){
cardrank result = NIL;
cardrank onePairTest = isOnePair(hand, NIL);
/* check that there are not two cards with matching ranks */
if (onePairTest == NIL) {
cardrank first = hand[0] -> rank;
cardrank second = hand[1] -> rank;
cardrank last = hand[POKER_HAND - 1] -> rank;
if ((last - first) == (POKER_HAND - 1)) {
/* cards are in sequence */
result = last;
}
else if ((first == ACE) && (last == KING) && ((last - second) == POKER_HAND - 2)){
/* royal straight */
result = ACE;
}
}
return result;
}
bool Util::isFullHouse()
{
return (isThreeOfAKind() && isOnePair());
}
