double SceneEdge::length() const { if (isStraight()) return (nodeEnd->point - nodeStart->point).magnitude(); else return radius() * angle / 180.0 * M_PI; }
/************************************** 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; }
bool RPolyline::hasArcSegments() const { for (int i=0; i<bulges.size(); i++) { if (!isStraight(bulges[i])) { return true; } } return false; }
/* 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; }
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; }
// 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 */ 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); }
double SceneEdge::distance(const Point &point) const { logMessage("SceneEdge::distance()"); if (isStraight()) { double t = ((point.x-nodeStart->point.x)*(nodeEnd->point.x-nodeStart->point.x) + (point.y-nodeStart->point.y)*(nodeEnd->point.y-nodeStart->point.y)) / ((nodeEnd->point.x-nodeStart->point.x)*(nodeEnd->point.x-nodeStart->point.x) + (nodeEnd->point.y-nodeStart->point.y)*(nodeEnd->point.y-nodeStart->point.y)); if (t > 1.0) t = 1.0; if (t < 0.0) t = 0.0; double x = nodeStart->point.x + t*(nodeEnd->point.x-nodeStart->point.x); double y = nodeStart->point.y + t*(nodeEnd->point.y-nodeStart->point.y); return sqrt(sqr(point.x-x) + sqr(point.y-y)); } else { Point c = center(); double R = radius(); double distance = (point - c).magnitude(); // point and radius are similar if (distance < EPS_ZERO) return R; Point t = (point - c) / distance; double l = ((point - c) - t * R).magnitude(); double z = (t.angle() - (nodeStart->point - c).angle())/M_PI*180.0; if (z < 0) z = z + 360.0; // interval (0, 360) if ((z > 0) && (z < angle)) return l; double a = (point - nodeStart->point).magnitude(); double b = (point - nodeEnd->point).magnitude(); return qMin(a, b); } }
Comb::Combs Comb::getComb(const QStringList & cards) const { if (isStraightFlash(cards)) { return Comb::StraightFlash; } if (isCare(cards)) { return Comb::Care; } if (isFullHouse(cards)) { return Comb::FullHouse; } if (isFlash(cards)) { return Comb::Flash; } if (isStraight(cards)) { return Comb::Straight; } if (isThreeOfKind(cards)) { return Comb::ThreeOfKind; } if (isTwoPair(cards)) { return Comb::TwoPair; } if (isPair(cards)) { return Comb::Pair; } return Comb::Trash; }
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; }
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 }
// Returns if the dice form a large straight const bool DiceRoll::isLargeStraight() const { return isStraight(0,5); }
// Returns if the dice form a small straight const bool DiceRoll::isSmallStraight() const { return isStraight(0,4) or isStraight(1,4); }
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; }
bool Hand::isStraightFlush() const { return (isStraight() && isFlush()); }
bool Comb::isStraightFlash(const QStringList & cards) const { return (isFlash(cards) && isStraight(cards)); }
uint8_t isStraightFlush(uint8_t * const hand) { return isFlush(hand) && isStraight(hand); }
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; }