public void TestGetCategory35_StraightFlush()
{
IHand hand = new Hand("A♦ K♦ Q♦ J♦ 10♦");
HandCategory category = handEvaluator.GetCategory(hand);
Assert.AreEqual(HandCategory.StraightFlush, category, "Straight flush is not identified correctly.");
}
public void TestGetCategory32_FourOfAKind()
{
IHand hand = new Hand("7♣ 7♠ 7♦ 7♥ 10♣");
HandCategory category = handEvaluator.GetCategory(hand);
Assert.AreEqual(HandCategory.FourOfAKind, category, "Four of a kind is not identified correctly.");
}
public void TestGetCategory29_FullHouse()
{
IHand hand = new Hand("Q♣ Q♦ Q♠ 9♥ 9♣");
HandCategory category = handEvaluator.GetCategory(hand);
Assert.AreEqual(HandCategory.FullHouse, category, "Full house is not identified correctly.");
}
public void TestGetCategory23_Flush()
{
IHand hand = new Hand("K♥ Q♥ 9♥ 5♥ 4♥");
HandCategory category = handEvaluator.GetCategory(hand);
Assert.AreEqual(HandCategory.Flush, category, "Flush is not identified correctly.");
}
public void TestGetCategory2_HighCard()
{
IHand hand = new Hand("K♥ J♥ 8♣ 7♦ 4♠");
HandCategory category = handEvaluator.GetCategory(hand);
Assert.AreEqual(HandCategory.HighCard, category, "High card is not identified correctly.");
}
public void TestGetCategory18_Straight()
{
IHand hand = new Hand("A♣ K♣ Q♦ J♠ 10♠");
HandCategory category = handEvaluator.GetCategory(hand);
Assert.AreEqual(HandCategory.Straight, category, "Straight is not identified correctly.");
}
public void TestGetCategory4_OnePair()
{
IHand hand = new Hand("4♥ 4♠ K♠ 10♦ 5♠");
HandCategory category = handEvaluator.GetCategory(hand);
Assert.AreEqual(HandCategory.OnePair, category, "One pair is not identified correctly.");
}
public void TestGetCategory20_NotStraight()
{
IHand hand = new Hand("3♠ 2♦ A♥ K♠ Q♣");
HandCategory category = handEvaluator.GetCategory(hand);
Assert.AreEqual(HandCategory.HighCard, category, "High card is not identified correctly.");
}
public void TestGetCategory15_ThreeOfAKind()
{
IHand hand = new Hand("4♦ 4♣ 4♠ 8♣ 7♦");
HandCategory category = handEvaluator.GetCategory(hand);
Assert.AreEqual(HandCategory.ThreeOfAKind, category, "Three of a kind is not identified correctly.");
}
public void TestGetCategory10_TwoPair()
{
IHand hand = new Hand("K♣ K♦ 9♠ 9♥ 5♥");
HandCategory category = handEvaluator.GetCategory(hand);
Assert.AreEqual(HandCategory.TwoPair, category, "Two pair is not identified correctly.");
}
public void Arrange(PokerPlayer player)
{
this.Copy(player);
if (CheckIsRoyalFlush())
{
this.Category = HandCategory.RoyalFlush;
}
else if (CheckIsFourOfAKind())
{
this.Category = HandCategory.FourOfAKind;
}
else if (CheckIsStraightFlush())
{
this.Category = HandCategory.StraightFlush;
}
else if (CheckIsFullHouse())
{
this.Category = HandCategory.FullHouse;
}
else if (CheckIsFlush())
{
this.Category = HandCategory.Flush;
}
else if (CheckIsStraight())
{
this.Category = HandCategory.Straight;
}
else if (CheckIsThreeOfAKind())
{
this.Category = HandCategory.ThreeOfaKind;
}
else if (CheckIsTwoPair())
{
this.Category = HandCategory.TwoPair;
}
else if (CheckIsPair())
{
this.Category = HandCategory.OnePair;
}
else
{
this.Category = HandCategory.HighCard;
}
//Get Score to get High Card
this.Score = this.CardsOnHand.AsEnumerable().Sum(r => (int)r.Rank);
}
public void TestGetCategory1_HighCard()
{
ICard[] cards = new ICard[5]
{
new Card(CardRank.Queen, CardSuit.Diamonds),
new Card(CardRank.King, CardSuit.Hearts),
new Card(CardRank.Two, CardSuit.Hearts),
new Card(CardRank.Eight, CardSuit.Spades),
new Card(CardRank.Nine, CardSuit.Clubs)
};
IHand hand = new Hand(cards);
HandCategory category = handEvaluator.GetCategory(hand);
Assert.AreEqual(HandCategory.HighCard, category, "High card is not identified correctly.");
}
public void PairTest()
{
HandCategory expectedCategory = HandCategory.Pair;
Card expectedHighCard = new Card(CardRank.Six, CardSuit.Diamond);
ObservableCollection <Card> cards = new ObservableCollection <Card> {
new Card(CardRank.Two, CardSuit.Spade),
new Card(CardRank.Queen, CardSuit.Club),
new Card(CardRank.Six, CardSuit.Heart),
new Card(CardRank.Six, CardSuit.Diamond),
new Card(CardRank.Three, CardSuit.Diamond)
};
Hand hand = new Hand("TestName", cards);
Assert.AreEqual(hand.Category, expectedCategory);
Assert.AreEqual(hand.HighCard, expectedHighCard);
}
public void StraightTest()
{
HandCategory expectedCategory = HandCategory.Straight;
Card expectedHighCard = new Card(CardRank.Six, CardSuit.Diamond);
ObservableCollection <Card> cards = new ObservableCollection <Card> {
new Card(CardRank.Two, CardSuit.Spade),
new Card(CardRank.Five, CardSuit.Diamond),
new Card(CardRank.Four, CardSuit.Diamond),
new Card(CardRank.Six, CardSuit.Diamond),
new Card(CardRank.Three, CardSuit.Diamond)
};
Hand hand = new Hand("TestName", cards);
Assert.AreEqual(hand.Category, expectedCategory);
Assert.AreEqual(hand.HighCard, expectedHighCard);
}
public void FlushTest()
{
HandCategory expectedCategory = HandCategory.Flush;
Card expectedHighCard = new Card(CardRank.Queen, CardSuit.Diamond);
ObservableCollection <Card> cards = new ObservableCollection <Card> {
new Card(CardRank.Queen, CardSuit.Diamond),
new Card(CardRank.Eight, CardSuit.Diamond),
new Card(CardRank.Five, CardSuit.Diamond),
new Card(CardRank.Three, CardSuit.Diamond),
new Card(CardRank.Seven, CardSuit.Diamond)
};
Hand hand = new Hand("TestName", cards);
Assert.AreEqual(hand.Category, expectedCategory);
Assert.AreEqual(hand.HighCard, expectedHighCard);
}
public void FullHouse2Low3HighTest()
{
HandCategory expectedCategory = HandCategory.FullHouse;
Card expectedHighCard = new Card(CardRank.Jack, CardSuit.Spade);
ObservableCollection <Card> cards = new ObservableCollection <Card> {
new Card(CardRank.Five, CardSuit.Spade),
new Card(CardRank.Jack, CardSuit.Club),
new Card(CardRank.Five, CardSuit.Heart),
new Card(CardRank.Five, CardSuit.Diamond),
new Card(CardRank.Jack, CardSuit.Spade)
};
Hand hand = new Hand("TestName", cards);
Assert.AreEqual(hand.Category, expectedCategory);
Assert.AreEqual(hand.HighCard, expectedHighCard);
}
public void StraightFlushTest()
{
HandCategory expectedCategory = HandCategory.StraightFlush;
Card expectedHighCard = new Card(CardRank.Ace, CardSuit.Spade);
ObservableCollection <Card> cards = new ObservableCollection <Card> {
new Card(CardRank.Ten, CardSuit.Spade),
new Card(CardRank.Jack, CardSuit.Spade),
new Card(CardRank.Queen, CardSuit.Spade),
new Card(CardRank.King, CardSuit.Spade),
new Card(CardRank.Ace, CardSuit.Spade)
};
Hand hand = new Hand("TestName", cards);
Assert.AreEqual(hand.Category, expectedCategory);
Assert.AreEqual(hand.HighCard, expectedHighCard);
}
public void FourOfAKindHighTest()
{
HandCategory expectedCategory = HandCategory.FourOfAKind;
Card expectedHighCard = new Card(CardRank.Jack, CardSuit.Spade); // High card should *not* be the Ace of Spades.
ObservableCollection <Card> cards = new ObservableCollection <Card> {
new Card(CardRank.Jack, CardSuit.Spade),
new Card(CardRank.Jack, CardSuit.Heart),
new Card(CardRank.Jack, CardSuit.Diamond),
new Card(CardRank.Jack, CardSuit.Club),
new Card(CardRank.Three, CardSuit.Spade)
};
Hand hand = new Hand("TestName", cards);
Assert.AreEqual(hand.Category, expectedCategory);
Assert.AreEqual(hand.HighCard, expectedHighCard);
}
/// <summary>
/// Compares two poker hands.
/// </summary>
/// <param name="hand1">The first hand.</param>
/// <param name="hand2">The second hand.</param>
/// <returns>Less than zero if <paramref name="hand1"/> ranks lower than
/// <paramref name="hand2"/>, zero if the hands are of equal value,
/// greater than zero if <paramref name="hand1"/> ranks higher than
/// <paramref name="hand2"/>.</returns>
public int CompareHands(IHand hand1, IHand hand2)
{
HandCategory category1 = this.GetCategory(hand1);
HandCategory category2 = this.GetCategory(hand2);
if (category1 < category2)
{
// hand1 ranks lower than hand2
return(-1);
}
if (category1 > category2)
{
// hand1 ranks above hand2
return(1);
}
hand1.Sort();
hand2.Sort();
// hand1 and hand2 are of the same type
switch (category1)
{
case HandCategory.StraightFlush:
case HandCategory.Straight:
{
return(this.CompareStraightHands(hand1, hand2));
}
case HandCategory.FourOfAKind:
{
return(this.CompareFourOfAKindHands(hand1, hand2));
}
case HandCategory.FullHouse:
{
return(this.CompareFullHouseHands(hand1, hand2));
}
case HandCategory.Flush:
{
return(this.CompareHighCardHands(hand1, hand2));
}
case HandCategory.ThreeOfAKind:
{
return(this.CompareThreeOfAKindHands(hand1, hand2));
}
case HandCategory.TwoPair:
{
return(this.CompareTwoPairHands(hand1, hand2));
}
case HandCategory.OnePair:
{
return(this.CompareOnePairHands(hand1, hand2));
}
default:
{
return(this.CompareHighCardHands(hand1, hand2));
}
}
}
//This Evaluates what kind of card combination player got
public void Evaluate()
{
if (this.AllSameSuit() != -1 && this.Straight() != -1)
{
if (this.getCard(0).Value == 10)
{
this.category = HandCategory.ROYAL_FLUSH;
this.handValue = 9999;
return;
}
else
{
this.category = HandCategory.STRAIGHT_FLUSH;
return;
}
}
if (this.Four() != -1)
{
this.category = HandCategory.FOUR_OF_A_KIND;
return;
}
if (this.FullHouse() != -1)
{
this.category = HandCategory.FULL_HOUSE;
return;
}
if (this.AllSameSuit() != -1)
{
this.category = HandCategory.FLUSH;
return;
}
if (this.Straight() != -1)
{
this.category = HandCategory.STRAIGHT;
return;
}
if (this.Three() != -1)
{
this.category = HandCategory.THREE_OF_A_KIND;
return;
}
if (this.TwoPairs() != -1)
{
this.category = HandCategory.TWO_PAIRS;
return;
}
if (this.Pair() != -1)
{
this.category = HandCategory.ONE_PAIR;
return;
}
this.handValue = this.getCard(4).Value;
this.category = HandCategory.HIGH_CARD;
}
public HandGroup(Spot spot, HandCategory category, HandType type) : this(type)
{
this.spot = spot;
this.category = category;
}
public void TestGetCategory36_ThrowsException()
{
IHand hand = new Hand("A♦ A♦ Q♦ J♦ 10♦");
HandCategory category = handEvaluator.GetCategory(hand);
}
private HandCards(CardGroup _cardGroup) : base(_cardGroup)
{
this.handCategory = GetCategory();
}
