Exemple #1
0
        public static Enums.Winner Compare(List <Card> blackCards, List <Card> whiteCards)
        {
            Enums.Winner _winner = Enums.Winner.Tie;

            Enums.Hand _blackHand = HandRecognizer.Recognize(blackCards);
            Enums.Hand _whiteHand = HandRecognizer.Recognize(whiteCards);

            if (_blackHand > _whiteHand)
            {
                _winner = Enums.Winner.Black;
            }
            else if (_blackHand < _whiteHand)
            {
                _winner = Enums.Winner.White;
            }
            else             // Need to break the tie
            {
                switch (_blackHand)
                {
                case Enums.Hand.HighCard:
                    _winner = TieSettler.HighCard(blackCards, whiteCards);
                    break;

                case Enums.Hand.Pair:
                    _winner = TieSettler.Pair(blackCards, whiteCards);
                    break;

                case Enums.Hand.TwoPair:
                    _winner = TieSettler.TwoPair(blackCards, whiteCards);
                    break;

                case Enums.Hand.ThreeOfAKind:
                    _winner = TieSettler.ThreeOfAKind(blackCards, whiteCards);
                    break;

                case Enums.Hand.Straight:
                    _winner = TieSettler.Straight(blackCards, whiteCards);
                    break;

                case Enums.Hand.Flush:
                    _winner = TieSettler.Flush(blackCards, whiteCards);
                    break;

                case Enums.Hand.FullHouse:
                    _winner = TieSettler.FullHouse(blackCards, whiteCards);
                    break;

                case Enums.Hand.FourOfAKind:
                    _winner = TieSettler.FourOfAKind(blackCards, whiteCards);
                    break;

                case Enums.Hand.StraightFlush:
                    _winner = TieSettler.StraightFlush(blackCards, whiteCards);
                    break;
                }
            }

            return(_winner);
        }
        public static Enums.Hand Recognize(List <Card> cards)
        {
            int _uniqueCards = getUniqueFaceValueCount(cards);

            Enums.Hand _hand = Enums.Hand.HighCard;

            switch (_uniqueCards)
            {
            case 5:
                // Five unique cards narrows it down to either HighCard, Straight, Flush, or StraightFlush
                bool _isFlush    = isFlush(cards);
                bool _isStraight = isStraight(cards);

                if (_isStraight && _isFlush)
                {
                    _hand = Enums.Hand.StraightFlush;
                }
                else if (_isStraight && !_isFlush)
                {
                    _hand = Enums.Hand.Straight;
                }
                else if (!_isStraight && _isFlush)
                {
                    _hand = Enums.Hand.Flush;
                }
                else
                {
                    _hand = Enums.Hand.HighCard;
                }
                break;

            case 4:
                // Four unique cards narrows it down to a Pair
                _hand = Enums.Hand.Pair;
                break;

            case 3:
                // Three unique cards narrows it down to TwoPair or ThreeOfAKind

                // Examine the first card, and count the number of other cards in the hand with the same facevalue
                bool _noClearWinner = true;
                int  _cardToExamine = 0;
                while (_noClearWinner)
                {
                    int _faceValueToMatch = CountCardsMatchingFaceValue(cards.ElementAt(_cardToExamine).FaceValue, cards);
                    switch (_faceValueToMatch)
                    {
                    case 1:
                        // Unclear winner, examine next card
                        _cardToExamine++;
                        break;

                    case 2:
                        // Having two of a card means the hand has at least one pair, making it a TwoPair
                        _hand          = Enums.Hand.TwoPair;
                        _noClearWinner = false;
                        break;

                    case 3:
                        // Having three of a card is a ThreeOfAKind
                        _hand          = Enums.Hand.ThreeOfAKind;
                        _noClearWinner = false;
                        break;
                    }
                }

                break;

            case 2:
                // Two unique cards narrows it down to either a FullHouse or FourOfAKind

                // Examine the first card, and count the number of other cards in the hand with the same facevalue
                int _FaceValueToMatch = CountCardsMatchingFaceValue(cards.ElementAt(0).FaceValue, cards);
                switch (_FaceValueToMatch)
                {
                case 1:
                    // Any unique card means that the hand is a FourOfAKind
                    _hand = Enums.Hand.FourOfAKind;
                    break;

                case 2:
                    // Having two of a card means the hand is a FullHouse
                    _hand = Enums.Hand.FullHouse;
                    break;

                case 3:
                    // Having three of a card means the hand is a FullHouse
                    _hand = Enums.Hand.FullHouse;
                    break;

                case 4:
                    // Having four of a card is a FourOfAKind
                    _hand = Enums.Hand.FourOfAKind;
                    break;
                }
                break;
            }

            return(_hand);
        }