public void ReturnsStraightFlushWhenGivenAStraightFlush()
{
// Arrange
const HandRanking expected = HandRanking.StraightFlush;
hand = new List <Card>()
{
new Card()
{
Suit = CardSuit.Spades, Value = CardValue.Nine
},
new Card()
{
Suit = CardSuit.Spades, Value = CardValue.King
},
new Card()
{
Suit = CardSuit.Spades, Value = CardValue.Queen
},
new Card()
{
Suit = CardSuit.Spades, Value = CardValue.Jack
},
new Card()
{
Suit = CardSuit.Spades, Value = CardValue.Ten
}
};
// Act
var actual = target.Rank(hand);
// Assert
Assert.AreEqual(expected, actual);
}
public void ReturnsFourOfAKindWhenGivenAFourOfAKind()
{
// Arrange
const HandRanking expected = HandRanking.FourOfAKind;
hand = new List <Card>()
{
new Card()
{
Suit = CardSuit.Spades, Value = CardValue.Nine
},
new Card()
{
Suit = CardSuit.Diamonds, Value = CardValue.Nine
},
new Card()
{
Suit = CardSuit.Clubs, Value = CardValue.Nine
},
new Card()
{
Suit = CardSuit.Hearts, Value = CardValue.Nine
},
new Card()
{
Suit = CardSuit.Spades, Value = CardValue.Ten
}
};
// Act
var actual = target.Rank(hand);
// Assert
Assert.AreEqual(expected, actual);
}
public override string ToString()
{
switch (HandRanking)
{
case HandRanking.StraightFlush:
case HandRanking.Straight:
case HandRanking.Flush:
return($"{HandRanking.Humanize()}, {((Rank)Kickers[0]).Humanize()} high.");
case HandRanking.FourOfAKind:
case HandRanking.ThreeOfAKind:
return($"{HandRanking.Humanize()}, {((Rank)Kickers[0]).Humanize()}s.");
case HandRanking.FullHouse:
return($"{HandRanking.Humanize()}, {((Rank)Kickers[0]).Humanize()}s over {((Rank)Kickers[1]).Humanize()}s.");
case HandRanking.Pair:
return($"{HandRanking.Humanize()} of {((Rank)Kickers[0]).Humanize()}s.");
case HandRanking.HighCard:
return($"{HandRanking.Humanize()}, {((Rank)Kickers[0]).Humanize()}.");
default:
return("Unknown");
}
}
public HandRanking BestHand(List <Card> hand, List <Card> communityCards)
{
var cards = hand.Concat(communityCards).ToList();
var bestHand = new HandRanking(hand, DetermineBestRank(cards));
return(bestHand);
}
public void ReturnsStraightWhenGivenAStraight()
{
// Arrange
const HandRanking expected = HandRanking.Straight;
hand = new List <Card>()
{
new Card()
{
Suit = CardSuit.Spades, Value = CardValue.Nine
},
new Card()
{
Suit = CardSuit.Spades, Value = CardValue.Seven
},
new Card()
{
Suit = CardSuit.Clubs, Value = CardValue.Eight
},
new Card()
{
Suit = CardSuit.Hearts, Value = CardValue.Six
},
new Card()
{
Suit = CardSuit.Diamonds, Value = CardValue.Five
}
};
// Act
var actual = target.Rank(hand);
// Assert
Assert.AreEqual(expected, actual);
}
public void ReturnsHighCardWhenGivenAHighCard()
{
// Arrange
const HandRanking expected = HandRanking.HighCard;
hand = new List <Card>()
{
new Card()
{
Suit = CardSuit.Spades, Value = CardValue.Nine
},
new Card()
{
Suit = CardSuit.Spades, Value = CardValue.Seven
},
new Card()
{
Suit = CardSuit.Clubs, Value = CardValue.Jack
},
new Card()
{
Suit = CardSuit.Hearts, Value = CardValue.Queen
},
new Card()
{
Suit = CardSuit.Diamonds, Value = CardValue.Two
}
};
// Act
var actual = target.Rank(hand);
// Assert
Assert.AreEqual(expected, actual);
}
private void DetermineRank()
{
_rank = HandRanking.Unknown;
List <HandRanking> availableRanks = new List <HandRanking>
{
HandRanking.HighCard,
HandRanking.Pair,
HandRanking.TwoPair,
HandRanking.ThreeOfAKind,
HandRanking.Straight,
HandRanking.Flush,
HandRanking.FullHouse,
HandRanking.FourOfAKind,
HandRanking.StraightFlush,
HandRanking.RoyalFlush
};
availableRanks.Reverse();
if (!HasFlush())
{
availableRanks.Remove(HandRanking.Flush);
availableRanks.Remove(HandRanking.StraightFlush);
availableRanks.Remove(HandRanking.RoyalFlush);
}
if (!HasStraight())
{
availableRanks.Remove(HandRanking.Straight);
}
if (!HasTriplet())
{
availableRanks.Remove(HandRanking.ThreeOfAKind);
availableRanks.Remove(HandRanking.FullHouse);
}
if (!HasPair())
{
availableRanks.Remove(HandRanking.Pair);
availableRanks.Remove(HandRanking.TwoPair);
}
foreach (HandRanking potentialRank in availableRanks)
{
if (Satisfies(potentialRank))
{
_rank = potentialRank;
break;
}
}
Debug.Assert(_rank != HandRanking.Unknown, "Rank should never be unknown at end of DetermineRank");
}
public void Add(Card c)
{
if (_cards.Count == 5)
{
throw new InvalidOperationException("Hand can not exceed 5 cards");
}
_cards.Add(c);
if (_cards.Count == 5)
{
_rank = HandCatagoriserChain.GetRank(this);
}
}
public void Add(Card c)
{
if (_cards.Count == 5)
{
throw new InvalidOperationException("Cannot add more than 5 cards to a hand.");
}
_cards.Add(c);
if (_cards.Count == 5)
{
_rank = HandCatagorizerChain.GetRank(this);
}
}
public void Add(Card card)
{
if (_cards.Count >= 5)
{
throw new IndexOutOfRangeException("Cannot add more then five cards.");
}
_cards.Add(card);
if (_cards.Count == 5)
{
Rank = HandCategorizerChain.GetRank(this);
}
}
public void Add(Card c)
{
if(_cards.Count == 5)
{
throw new InvalidOperationException("Cannot add more than 5 cards to a hand.");
}
_cards.Add(c);
if(_cards.Count == 5)
{
_rank = HandCatagorizerChain.GetRank(this);
}
}
public Result CompareWith(PokerHand otherHand)
{
//then determine rankings
this._ranking = this.DetermineHandRanking();
otherHand._ranking = otherHand.DetermineHandRanking();
//decide result based on hand rankings
if (this._ranking > otherHand._ranking)
{
return(Result.Win);
}
if (this._ranking < otherHand._ranking)
{
return(Result.Loss);
}
return(DetermineTieBreaker(otherHand));
}
private bool Satisfies(HandRanking potentialRank)
{
switch (potentialRank)
{
case HandRanking.HighCard:
return(true);
case HandRanking.Pair:
return(HasNofKind(2));
case HandRanking.TwoPair:
return(HasTwoPair());
case HandRanking.ThreeOfAKind:
return(HasNofKind(3));
case HandRanking.Straight:
return(HasStraight());
case HandRanking.Flush:
return(HasFlush());
case HandRanking.FullHouse:
return(HasFullHouse());
case HandRanking.FourOfAKind:
return(HasNofKind(4));
case HandRanking.StraightFlush:
return(HasFlush() && HasStraight());
case HandRanking.RoyalFlush:
return(HasFlush() && HasStraight() && _cards[_cards.Count - 1].Value == Value.Ace);
default:
throw new NotImplementedException();
}
}
public static IEnumerable <Card> SortCardsByRanking(this IEnumerable <Card> cards, HandRanking ranking)
{
if (ranking.Equals(HandRanking.OnePair) || ranking.Equals(HandRanking.TwoPair) ||
ranking.Equals(HandRanking.ThreeOfAKind) | ranking.Equals(HandRanking.FourOfAKind) |
ranking.Equals(HandRanking.FullHouse))
{
return(cards.GroupBy(card => card.rank).OrderByDescending(group => group.Count())
.ThenByDescending(group => group.First().rank)
.SelectMany(group => group.Select(card => card)));
}
return(cards.OrderBy(card => card.rank));
}
private void DetermineRank()
{
_rank = HandRanking.Unknown;
List<HandRanking> availableRanks = new List<HandRanking>
{
HandRanking.HighCard,
HandRanking.Pair,
HandRanking.TwoPair,
HandRanking.ThreeOfAKind,
HandRanking.Straight,
HandRanking.Flush,
HandRanking.FullHouse,
HandRanking.FourOfAKind,
HandRanking.StraightFlush,
HandRanking.RoyalFlush
};
availableRanks.Reverse();
if(!HasFlush())
{
availableRanks.Remove(HandRanking.Flush);
availableRanks.Remove(HandRanking.StraightFlush);
availableRanks.Remove(HandRanking.RoyalFlush);
}
if (!HasStraight())
{
availableRanks.Remove(HandRanking.Straight);
}
if (!HasTriplet())
{
availableRanks.Remove(HandRanking.ThreeOfAKind);
availableRanks.Remove(HandRanking.FullHouse);
}
if(!HasPair())
{
availableRanks.Remove(HandRanking.Pair);
availableRanks.Remove(HandRanking.TwoPair);
}
foreach(HandRanking potentialRank in availableRanks)
{
if(Satisfies(potentialRank))
{
_rank = potentialRank;
break;
}
}
Debug.Assert(_rank != HandRanking.Unknown, "Rank should never be unknown at end of DetermineRank");
}
/// <summary>
/// Note: cards must be ordered numerically for this to function correctly.
/// @TODO: Account for Jokers & wildcards (currently only supports 5 of a kind).
/// </summary>
public void GetBestHand()
{
highestValue = hand[4].value;
int sameValueCount = 0;
bool run = true;
bool flush = true;
Card lastCard = null;
foreach (Card card in hand)
{
if (run && lastCard != null)
{
if (lastCard.value != (card.value - 1))
{
// check edge case with ace
// 10, J, Q, K, Ace
// 2, 3, 4, 5, Ace
if (!(card.value == CardValue.Ace &&
(lastCard.value == CardValue.King ||
lastCard.value == CardValue.Five)))
{
run = false;
}
}
}
if (flush && lastCard != null)
{
if (lastCard.suit != card.suit)
{
flush = false;
}
}
if (lastCard != null && lastCard.value == card.value)
{
switch (++sameValueCount)
{
case 2:
if (firstPair == null)
{
firstPair = new Tuple <CardValue, int>(card.value, 2);
}
else
{
secondPair = new Tuple <CardValue, int>(card.value, 2);
}
break;
case 3:
if (firstPair.Item1 == card.value)
{
firstPair = new Tuple <CardValue, int>(card.value, 3);
}
else
{
secondPair = new Tuple <CardValue, int>(card.value, 3);
}
break;
case 4:
firstPair = new Tuple <CardValue, int>(card.value, 4);
break;
case 5:
firstPair = new Tuple <CardValue, int>(card.value, 5);
break;
}
}
else
{
sameValueCount = 1;
}
lastCard = card;
}
if (run)
{
if (flush)
{
if (hand[3].value == CardValue.King)
{
ranking = HandRanking.RoyalFlush;
Debug.Log("Royal Flush!!");
}
else
{
ranking = HandRanking.StraighFlush;
Debug.Log("Straight flush with " + highestValue + " high");
}
}
else
{
ranking = HandRanking.Straight;
Debug.Log("Run with " + highestValue + " high");
}
}
else if (flush)
{
ranking = HandRanking.Flush;
Debug.Log("Flush " + highestValue + " high");
}
else if (firstPair != null)
{
switch (firstPair.Item2)
{
case 2:
if (secondPair == null)
{
ranking = HandRanking.Pair;
Debug.Log("One pair of " + firstPair.Item1);
}
else
{
if (secondPair.Item2 == 2)
{
ranking = HandRanking.TwoPair;
Debug.Log("Two pairs of " + firstPair.Item1 + " and " + secondPair.Item1);
}
else
{
ranking = HandRanking.FullHouse;
Debug.Log("Full house of " + firstPair.Item1 + " and " + secondPair.Item1);
}
}
break;
case 3:
if (secondPair == null)
{
ranking = HandRanking.ThreeOfAKind;
Debug.Log("Three of a kind of " + firstPair.Item1);
}
else
{
ranking = HandRanking.FullHouse;
Debug.Log("Full house of " + firstPair.Item1 + " and " + secondPair.Item1);
}
break;
case 4:
ranking = HandRanking.FourOfAKind;
Debug.Log("4 of a kind of " + firstPair.Item1);
break;
case 5:
ranking = HandRanking.FiveOfAKind;
Debug.Log("5 of a kind of " + firstPair.Item1);
break;
}
}
else
{
Debug.Log("High card: " + highestValue);
}
}
protected override int TieBreaker(HandRanking other)
{
throw new NotImplementedException();
}
private bool Satisfies(HandRanking potentialRank)
{
switch (potentialRank)
{
case HandRanking.HighCard:
return true;
case HandRanking.Pair:
return HasNofKind(2);
case HandRanking.TwoPair:
return HasTwoPair();
case HandRanking.ThreeOfAKind:
return HasNofKind(3);
case HandRanking.Straight:
return HasStraight();
case HandRanking.Flush:
return HasFlush();
case HandRanking.FullHouse:
return HasFullHouse();
case HandRanking.FourOfAKind:
return HasNofKind(4);
case HandRanking.StraightFlush:
return HasFlush() && HasStraight();
case HandRanking.RoyalFlush:
return HasFlush() && HasStraight() && _cards[_cards.Count - 1].Value == Value.Ace;
default:
throw new NotImplementedException();
}
}
public Probability(HandRanking ranking, double percentage) : this()
{
Ranking = ranking;
Percentage = percentage;
}
