private PokerHand GetHand(PlayingCard one, PlayingCard two, PlayingCard three, PlayingCard four, PlayingCard five)
{
OrderedCardSet cards = new OrderedCardSet(new List <PlayingCard> {
one, two, three, four, five
});
PokerHand hand = HoldemHand.IdentitfyHand(cards);
return(hand);
}
public void TestCardCombo()
{
PokerPlayer pl1 = new FakePokerPlayer();
PokerPlayer pl2 = new FakePokerPlayer();
ICardDealer dealer = new DefaultCardDealer();
dealer.ShuffleAndDealDeck(pl1, pl2);
List <OrderedCardSet> p1PossHands = HoldemHand.GetOpponentCombinationOfHandCards(dealer.FullDeck, pl2.HandCards, dealer.CommunityCards);
List <OrderedCardSet> p2PossHands = HoldemHand.GetOpponentCombinationOfHandCards(dealer.FullDeck, pl1.HandCards, dealer.CommunityCards);
List <PlayingCard> totalCards = new List <PlayingCard>();
totalCards.AddRange(pl1.HandCards);
totalCards.AddRange(dealer.CommunityCards);
Assert.AreEqual(7, totalCards.Count);
int len = 7;
int count = 0;
for (int t1 = 0; t1 < len; t1 += 1)
{
for (int t2 = t1 + 1; t2 < len; t2 += 1)
{
for (int t3 = t2 + 1; t3 < len; t3 += 1)
{
for (int t4 = t3 + 1; t4 < len; t4 += 1)
{
for (int t5 = t4 + 1; t5 < len; t5 += 1)
{
count += 1;
}
}
}
}
}
Assert.AreEqual(21, count);
List <OrderedCardSet> p1PokerHands = HoldemHand.GetCombinationOfPokerHands(pl1.HandCards, dealer.CommunityCards);
List <OrderedCardSet> p2PokerHands = HoldemHand.GetCombinationOfPokerHands(pl2.HandCards, dealer.CommunityCards);
Assert.AreEqual(990, p1PossHands.Count);
Assert.AreEqual(990, p2PossHands.Count);
Assert.AreEqual(21, p1PokerHands.Count);
Assert.AreEqual(21, p2PokerHands.Count);
pl1.Hand = HoldemHand.ChooseBestHand(pl1.HandCards, dealer.CommunityCards);
pl2.Hand = HoldemHand.ChooseBestHand(pl2.HandCards, dealer.CommunityCards);
// OrderedCardSet set = CardChances.GetOtherCards(dealer.FullDeck, pl2.HandCards, dealer.CommunityCards);
HoldemHand.HandPlayResult result = HoldemHand.TestHandChances(pl1.Hand, pl1.HandCards, dealer);
Assert.AreEqual(990, result.Wins + result.Losses + result.Ties);
}
public void TestGeneratingBestPokerHand()
{
//Arrange
HoldemHand[] HoldemHandArray = new HoldemHand[21];
PokerHand[] PokerHandArray = new PokerHand[21];
for (int i = 0; i < 21; ++i)
{
HoldemHandArray[i] = new HoldemHand();
}
for (int i = 0; i < 21; ++i)
{
PokerHandArray[i] = new PokerHand();
}
/***************************************/
HoldemHandArray[0].Hand[0] = new Card(Rank.Three, Suit.Club);
HoldemHandArray[0].Hand[1] = new Card(Rank.Three, Suit.Heart);
PokerHandArray[0].Hand[0] = new Card(Rank.Ace, Suit.Diamond);
PokerHandArray[0].Hand[1] = new Card(Rank.King, Suit.Diamond);
PokerHandArray[0].Hand[2] = new Card(Rank.Jack, Suit.Heart);
PokerHandArray[0].Hand[3] = new Card(Rank.Eight, Suit.Heart);
PokerHandArray[0].Hand[4] = new Card(Rank.Nine, Suit.Diamond);
HoldemHandArray[1].Hand[0] = new Card(Rank.Seven, Suit.Diamond);
HoldemHandArray[1].Hand[1] = new Card(Rank.Four, Suit.Diamond);
PokerHandArray[1].Hand[0] = new Card(Rank.Four, Suit.Club);
PokerHandArray[1].Hand[1] = new Card(Rank.Seven, Suit.Spade);
PokerHandArray[1].Hand[2] = new Card(Rank.Nine, Suit.Diamond);
PokerHandArray[1].Hand[3] = new Card(Rank.Seven, Suit.Club);
PokerHandArray[1].Hand[4] = new Card(Rank.Eight, Suit.Heart);
HoldemHandArray[2].Hand[0] = new Card(Rank.King, Suit.Spade);
HoldemHandArray[2].Hand[1] = new Card(Rank.Queen, Suit.Club);
PokerHandArray[2].Hand[0] = new Card(Rank.Six, Suit.Club);
PokerHandArray[2].Hand[1] = new Card(Rank.King, Suit.Diamond);
PokerHandArray[2].Hand[2] = new Card(Rank.Jack, Suit.Club);
PokerHandArray[2].Hand[3] = new Card(Rank.Two, Suit.Spade);
PokerHandArray[2].Hand[4] = new Card(Rank.Six, Suit.Diamond);
HoldemHandArray[3].Hand[0] = new Card(Rank.Seven, Suit.Club);
HoldemHandArray[3].Hand[1] = new Card(Rank.Three, Suit.Spade);
PokerHandArray[3].Hand[0] = new Card(Rank.Four, Suit.Heart);
PokerHandArray[3].Hand[1] = new Card(Rank.King, Suit.Heart);
PokerHandArray[3].Hand[2] = new Card(Rank.King, Suit.Spade);
PokerHandArray[3].Hand[3] = new Card(Rank.Five, Suit.Heart);
PokerHandArray[3].Hand[4] = new Card(Rank.Six, Suit.Heart);
HoldemHandArray[4].Hand[0] = new Card(Rank.Seven, Suit.Spade);
HoldemHandArray[4].Hand[1] = new Card(Rank.Eight, Suit.Diamond);
PokerHandArray[4].Hand[0] = new Card(Rank.Four, Suit.Diamond);
PokerHandArray[4].Hand[1] = new Card(Rank.Queen, Suit.Spade);
PokerHandArray[4].Hand[2] = new Card(Rank.Five, Suit.Club);
PokerHandArray[4].Hand[3] = new Card(Rank.King, Suit.Club);
PokerHandArray[4].Hand[4] = new Card(Rank.Ace, Suit.Club);
HoldemHandArray[5].Hand[0] = new Card(Rank.Two, Suit.Spade);
HoldemHandArray[5].Hand[1] = new Card(Rank.Queen, Suit.Spade);
PokerHandArray[5].Hand[0] = new Card(Rank.Queen, Suit.Diamond);
PokerHandArray[5].Hand[1] = new Card(Rank.Nine, Suit.Diamond);
PokerHandArray[5].Hand[2] = new Card(Rank.Ace, Suit.Spade);
PokerHandArray[5].Hand[3] = new Card(Rank.Four, Suit.Spade);
PokerHandArray[5].Hand[4] = new Card(Rank.Five, Suit.Spade);
HoldemHandArray[6].Hand[0] = new Card(Rank.Ace, Suit.Spade);
HoldemHandArray[6].Hand[1] = new Card(Rank.Four, Suit.Diamond);
PokerHandArray[6].Hand[0] = new Card(Rank.King, Suit.Diamond);
PokerHandArray[6].Hand[1] = new Card(Rank.Nine, Suit.Diamond);
PokerHandArray[6].Hand[2] = new Card(Rank.King, Suit.Club);
PokerHandArray[6].Hand[3] = new Card(Rank.King, Suit.Heart);
PokerHandArray[6].Hand[4] = new Card(Rank.King, Suit.Spade);
HoldemHandArray[7].Hand[0] = new Card(Rank.Seven, Suit.Spade);
HoldemHandArray[7].Hand[1] = new Card(Rank.Two, Suit.Spade);
PokerHandArray[7].Hand[0] = new Card(Rank.Three, Suit.Spade);
PokerHandArray[7].Hand[1] = new Card(Rank.Four, Suit.Spade);
PokerHandArray[7].Hand[2] = new Card(Rank.Five, Suit.Spade);
PokerHandArray[7].Hand[3] = new Card(Rank.Six, Suit.Spade);
PokerHandArray[7].Hand[4] = new Card(Rank.Eight, Suit.Spade);
HoldemHandArray[8].Hand[0] = new Card(Rank.Three, Suit.Heart);
HoldemHandArray[8].Hand[1] = new Card(Rank.Five, Suit.Club);
PokerHandArray[8].Hand[0] = new Card(Rank.Three, Suit.Diamond);
PokerHandArray[8].Hand[1] = new Card(Rank.Ten, Suit.Heart);
PokerHandArray[8].Hand[2] = new Card(Rank.Ten, Suit.Spade);
PokerHandArray[8].Hand[3] = new Card(Rank.Queen, Suit.Heart);
PokerHandArray[8].Hand[4] = new Card(Rank.Queen, Suit.Diamond);
HoldemHandArray[9].Hand[0] = new Card(Rank.Six, Suit.Diamond);
HoldemHandArray[9].Hand[1] = new Card(Rank.Three, Suit.Heart);
PokerHandArray[9].Hand[0] = new Card(Rank.Ten, Suit.Heart);
PokerHandArray[9].Hand[1] = new Card(Rank.Ten, Suit.Diamond);
PokerHandArray[9].Hand[2] = new Card(Rank.Queen, Suit.Diamond);
PokerHandArray[9].Hand[3] = new Card(Rank.Ten, Suit.Spade);
PokerHandArray[9].Hand[4] = new Card(Rank.Nine, Suit.Spade);
HoldemHandArray[10].Hand[0] = new Card(Rank.Jack, Suit.Diamond);
HoldemHandArray[10].Hand[1] = new Card(Rank.Nine, Suit.Spade);
PokerHandArray[10].Hand[0] = new Card(Rank.Nine, Suit.Diamond);
PokerHandArray[10].Hand[1] = new Card(Rank.Queen, Suit.Heart);
PokerHandArray[10].Hand[2] = new Card(Rank.Queen, Suit.Diamond);
PokerHandArray[10].Hand[3] = new Card(Rank.Queen, Suit.Spade);
PokerHandArray[10].Hand[4] = new Card(Rank.Nine, Suit.Heart);
HoldemHandArray[11].Hand[0] = new Card(Rank.Four, Suit.Spade);
HoldemHandArray[11].Hand[1] = new Card(Rank.Two, Suit.Heart);
PokerHandArray[11].Hand[0] = new Card(Rank.Four, Suit.Diamond);
PokerHandArray[11].Hand[1] = new Card(Rank.Nine, Suit.Heart);
PokerHandArray[11].Hand[2] = new Card(Rank.Two, Suit.Club);
PokerHandArray[11].Hand[3] = new Card(Rank.Nine, Suit.Spade);
PokerHandArray[11].Hand[4] = new Card(Rank.Nine, Suit.Diamond);
HoldemHandArray[12].Hand[0] = new Card(Rank.Two, Suit.Spade);
HoldemHandArray[12].Hand[1] = new Card(Rank.Seven, Suit.Club);
PokerHandArray[12].Hand[0] = new Card(Rank.Five, Suit.Club);
PokerHandArray[12].Hand[1] = new Card(Rank.Eight, Suit.Spade);
PokerHandArray[12].Hand[2] = new Card(Rank.Three, Suit.Spade);
PokerHandArray[12].Hand[3] = new Card(Rank.Six, Suit.Club);
PokerHandArray[12].Hand[4] = new Card(Rank.Four, Suit.Club);
HoldemHandArray[13].Hand[0] = new Card(Rank.King, Suit.Diamond);
HoldemHandArray[13].Hand[1] = new Card(Rank.Jack, Suit.Club);
PokerHandArray[13].Hand[0] = new Card(Rank.Seven, Suit.Club);
PokerHandArray[13].Hand[1] = new Card(Rank.Two, Suit.Club);
PokerHandArray[13].Hand[2] = new Card(Rank.Six, Suit.Diamond);
PokerHandArray[13].Hand[3] = new Card(Rank.Three, Suit.Club);
PokerHandArray[13].Hand[4] = new Card(Rank.Ace, Suit.Heart);
HoldemHandArray[14].Hand[0] = new Card(Rank.Jack, Suit.Diamond);
HoldemHandArray[14].Hand[1] = new Card(Rank.King, Suit.Diamond);
PokerHandArray[14].Hand[0] = new Card(Rank.Ten, Suit.Diamond);
PokerHandArray[14].Hand[1] = new Card(Rank.Six, Suit.Diamond);
PokerHandArray[14].Hand[2] = new Card(Rank.Seven, Suit.Diamond);
PokerHandArray[14].Hand[3] = new Card(Rank.King, Suit.Spade);
PokerHandArray[14].Hand[4] = new Card(Rank.Nine, Suit.Diamond);
HoldemHandArray[15].Hand[0] = new Card(Rank.Jack, Suit.Spade);
HoldemHandArray[15].Hand[1] = new Card(Rank.Ace, Suit.Club);
PokerHandArray[15].Hand[0] = new Card(Rank.King, Suit.Spade);
PokerHandArray[15].Hand[1] = new Card(Rank.Ace, Suit.Spade);
PokerHandArray[15].Hand[2] = new Card(Rank.Ace, Suit.Diamond);
PokerHandArray[15].Hand[3] = new Card(Rank.Ace, Suit.Heart);
PokerHandArray[15].Hand[4] = new Card(Rank.Queen, Suit.Club);
HoldemHandArray[16].Hand[0] = new Card(Rank.Queen, Suit.Spade);
HoldemHandArray[16].Hand[1] = new Card(Rank.Two, Suit.Spade);
PokerHandArray[16].Hand[0] = new Card(Rank.Queen, Suit.Heart);
PokerHandArray[16].Hand[1] = new Card(Rank.Ace, Suit.Club);
PokerHandArray[16].Hand[2] = new Card(Rank.Ace, Suit.Heart);
PokerHandArray[16].Hand[3] = new Card(Rank.Eight, Suit.Heart);
PokerHandArray[16].Hand[4] = new Card(Rank.Eight, Suit.Diamond);
HoldemHandArray[17].Hand[0] = new Card(Rank.Ace, Suit.Club);
HoldemHandArray[17].Hand[1] = new Card(Rank.Three, Suit.Heart);
PokerHandArray[17].Hand[0] = new Card(Rank.King, Suit.Club);
PokerHandArray[17].Hand[1] = new Card(Rank.Queen, Suit.Club);
PokerHandArray[17].Hand[2] = new Card(Rank.Jack, Suit.Club);
PokerHandArray[17].Hand[3] = new Card(Rank.Six, Suit.Diamond);
PokerHandArray[17].Hand[4] = new Card(Rank.Ten, Suit.Club);
HoldemHandArray[18].Hand[0] = new Card(Rank.Ace, Suit.Club);
HoldemHandArray[18].Hand[1] = new Card(Rank.Ten, Suit.Club);
PokerHandArray[18].Hand[0] = new Card(Rank.Six, Suit.Diamond);
PokerHandArray[18].Hand[1] = new Card(Rank.King, Suit.Club);
PokerHandArray[18].Hand[2] = new Card(Rank.Jack, Suit.Club);
PokerHandArray[18].Hand[3] = new Card(Rank.Three, Suit.Heart);
PokerHandArray[18].Hand[4] = new Card(Rank.Queen, Suit.Club);
HoldemHandArray[19].Hand[0] = new Card(Rank.Ten, Suit.Club);
HoldemHandArray[19].Hand[1] = new Card(Rank.Ace, Suit.Club);
PokerHandArray[19].Hand[0] = new Card(Rank.King, Suit.Club);
PokerHandArray[19].Hand[1] = new Card(Rank.Three, Suit.Heart);
PokerHandArray[19].Hand[2] = new Card(Rank.Queen, Suit.Club);
PokerHandArray[19].Hand[3] = new Card(Rank.Jack, Suit.Club);
PokerHandArray[19].Hand[4] = new Card(Rank.Six, Suit.Diamond);
HoldemHandArray[20].Hand[0] = new Card(Rank.Three, Suit.Heart);
HoldemHandArray[20].Hand[1] = new Card(Rank.Ace, Suit.Club);
PokerHandArray[20].Hand[0] = new Card(Rank.Queen, Suit.Club);
PokerHandArray[20].Hand[1] = new Card(Rank.Ten, Suit.Club);
PokerHandArray[20].Hand[2] = new Card(Rank.Jack, Suit.Club);
PokerHandArray[20].Hand[3] = new Card(Rank.Six, Suit.Diamond);
PokerHandArray[20].Hand[4] = new Card(Rank.King, Suit.Club);
//Act
PokerHandArray[0] = HoldemHandArray[0].FindBestPokerHand(PokerHandArray[0]);
PokerHandArray[1] = HoldemHandArray[1].FindBestPokerHand(PokerHandArray[1]);
PokerHandArray[2] = HoldemHandArray[2].FindBestPokerHand(PokerHandArray[2]);
PokerHandArray[3] = HoldemHandArray[3].FindBestPokerHand(PokerHandArray[3]);
PokerHandArray[4] = HoldemHandArray[4].FindBestPokerHand(PokerHandArray[4]);
PokerHandArray[5] = HoldemHandArray[5].FindBestPokerHand(PokerHandArray[5]);
PokerHandArray[6] = HoldemHandArray[6].FindBestPokerHand(PokerHandArray[6]);
PokerHandArray[7] = HoldemHandArray[7].FindBestPokerHand(PokerHandArray[7]);
PokerHandArray[8] = HoldemHandArray[8].FindBestPokerHand(PokerHandArray[8]);
PokerHandArray[9] = HoldemHandArray[9].FindBestPokerHand(PokerHandArray[9]);
PokerHandArray[10] = HoldemHandArray[10].FindBestPokerHand(PokerHandArray[10]);
PokerHandArray[11] = HoldemHandArray[11].FindBestPokerHand(PokerHandArray[11]);
PokerHandArray[12] = HoldemHandArray[12].FindBestPokerHand(PokerHandArray[12]);
PokerHandArray[13] = HoldemHandArray[13].FindBestPokerHand(PokerHandArray[13]);
PokerHandArray[14] = HoldemHandArray[14].FindBestPokerHand(PokerHandArray[14]);
PokerHandArray[15] = HoldemHandArray[15].FindBestPokerHand(PokerHandArray[15]);
PokerHandArray[16] = HoldemHandArray[16].FindBestPokerHand(PokerHandArray[16]);
PokerHandArray[17] = HoldemHandArray[17].FindBestPokerHand(PokerHandArray[17]);
PokerHandArray[18] = HoldemHandArray[18].FindBestPokerHand(PokerHandArray[18]);
PokerHandArray[19] = HoldemHandArray[19].FindBestPokerHand(PokerHandArray[19]);
PokerHandArray[20] = HoldemHandArray[20].FindBestPokerHand(PokerHandArray[20]);
//Assert
Array.Sort(PokerHandArray[0].Hand);
Array.Sort(PokerHandArray[1].Hand);
Array.Sort(PokerHandArray[2].Hand);
Array.Sort(PokerHandArray[3].Hand);
Array.Sort(PokerHandArray[4].Hand);
Array.Sort(PokerHandArray[5].Hand);
Array.Sort(PokerHandArray[6].Hand);
Array.Sort(PokerHandArray[7].Hand);
Array.Sort(PokerHandArray[8].Hand);
Array.Sort(PokerHandArray[9].Hand);
Array.Sort(PokerHandArray[10].Hand);
Array.Sort(PokerHandArray[11].Hand);
Array.Sort(PokerHandArray[12].Hand);
Array.Sort(PokerHandArray[13].Hand);
Array.Sort(PokerHandArray[14].Hand);
Array.Sort(PokerHandArray[15].Hand);
Array.Sort(PokerHandArray[16].Hand);
Array.Sort(PokerHandArray[17].Hand);
Array.Sort(PokerHandArray[18].Hand);
Array.Sort(PokerHandArray[19].Hand);
Array.Sort(PokerHandArray[20].Hand);
/***************************************/
Assert.AreEqual(new Card(Rank.Ace, Suit.Diamond), PokerHandArray[0].Hand[0]);
Assert.AreEqual(new Card(Rank.King, Suit.Diamond), PokerHandArray[0].Hand[1]);
Assert.AreEqual(new Card(Rank.Jack, Suit.Heart), PokerHandArray[0].Hand[2]);
Assert.AreEqual(new Card(Rank.Three, Suit.Club), PokerHandArray[0].Hand[3]);
Assert.AreEqual(new Card(Rank.Three, Suit.Heart), PokerHandArray[0].Hand[4]);
Assert.AreEqual(new Card(Rank.Seven, Suit.Diamond), PokerHandArray[1].Hand[0]);
Assert.AreEqual(new Card(Rank.Seven, Suit.Spade), PokerHandArray[1].Hand[1]);
Assert.AreEqual(new Card(Rank.Seven, Suit.Club), PokerHandArray[1].Hand[2]);
Assert.AreEqual(new Card(Rank.Four, Suit.Diamond), PokerHandArray[1].Hand[3]);
Assert.AreEqual(new Card(Rank.Four, Suit.Club), PokerHandArray[1].Hand[4]);
Assert.AreEqual(new Card(Rank.King, Suit.Spade), PokerHandArray[2].Hand[0]);
Assert.AreEqual(new Card(Rank.King, Suit.Diamond), PokerHandArray[2].Hand[1]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Club), PokerHandArray[2].Hand[2]);
Assert.AreEqual(new Card(Rank.Six, Suit.Club), PokerHandArray[2].Hand[3]);
Assert.AreEqual(new Card(Rank.Six, Suit.Diamond), PokerHandArray[2].Hand[4]);
Assert.AreEqual(new Card(Rank.Seven, Suit.Club), PokerHandArray[3].Hand[0]);
Assert.AreEqual(new Card(Rank.Six, Suit.Heart), PokerHandArray[3].Hand[1]);
Assert.AreEqual(new Card(Rank.Five, Suit.Heart), PokerHandArray[3].Hand[2]);
Assert.AreEqual(new Card(Rank.Four, Suit.Heart), PokerHandArray[3].Hand[3]);
Assert.AreEqual(new Card(Rank.Three, Suit.Spade), PokerHandArray[3].Hand[4]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Club), PokerHandArray[4].Hand[0]);
Assert.AreEqual(new Card(Rank.King, Suit.Club), PokerHandArray[4].Hand[1]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Spade), PokerHandArray[4].Hand[2]);
Assert.AreEqual(new Card(Rank.Eight, Suit.Diamond), PokerHandArray[4].Hand[3]);
Assert.AreEqual(new Card(Rank.Seven, Suit.Spade), PokerHandArray[4].Hand[4]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Spade), PokerHandArray[5].Hand[0]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Spade), PokerHandArray[5].Hand[1]);
Assert.AreEqual(new Card(Rank.Five, Suit.Spade), PokerHandArray[5].Hand[2]);
Assert.AreEqual(new Card(Rank.Four, Suit.Spade), PokerHandArray[5].Hand[3]);
Assert.AreEqual(new Card(Rank.Two, Suit.Spade), PokerHandArray[5].Hand[4]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Spade), PokerHandArray[6].Hand[0]);
Assert.AreEqual(new Card(Rank.King, Suit.Diamond), PokerHandArray[6].Hand[1]);
Assert.AreEqual(new Card(Rank.King, Suit.Club), PokerHandArray[6].Hand[2]);
Assert.AreEqual(new Card(Rank.King, Suit.Heart), PokerHandArray[6].Hand[3]);
Assert.AreEqual(new Card(Rank.King, Suit.Spade), PokerHandArray[6].Hand[4]);
Assert.AreEqual(new Card(Rank.Eight, Suit.Spade), PokerHandArray[7].Hand[0]);
Assert.AreEqual(new Card(Rank.Seven, Suit.Spade), PokerHandArray[7].Hand[1]);
Assert.AreEqual(new Card(Rank.Six, Suit.Spade), PokerHandArray[7].Hand[2]);
Assert.AreEqual(new Card(Rank.Five, Suit.Spade), PokerHandArray[7].Hand[3]);
Assert.AreEqual(new Card(Rank.Four, Suit.Spade), PokerHandArray[7].Hand[4]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Heart), PokerHandArray[8].Hand[0]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Diamond), PokerHandArray[8].Hand[1]);
Assert.AreEqual(new Card(Rank.Ten, Suit.Heart), PokerHandArray[8].Hand[2]);
Assert.AreEqual(new Card(Rank.Ten, Suit.Spade), PokerHandArray[8].Hand[3]);
Assert.AreEqual(new Card(Rank.Five, Suit.Club), PokerHandArray[8].Hand[4]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Diamond), PokerHandArray[9].Hand[0]);
Assert.AreEqual(new Card(Rank.Ten, Suit.Heart), PokerHandArray[9].Hand[1]);
Assert.AreEqual(new Card(Rank.Ten, Suit.Diamond), PokerHandArray[9].Hand[2]);
Assert.AreEqual(new Card(Rank.Ten, Suit.Spade), PokerHandArray[9].Hand[3]);
Assert.AreEqual(new Card(Rank.Nine, Suit.Spade), PokerHandArray[9].Hand[4]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Heart), PokerHandArray[10].Hand[0]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Diamond), PokerHandArray[10].Hand[1]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Spade), PokerHandArray[10].Hand[2]);
Assert.AreEqual(new Card(Rank.Nine, Suit.Spade), PokerHandArray[10].Hand[3]);
Assert.AreEqual(new Card(Rank.Nine, Suit.Heart), PokerHandArray[10].Hand[4]);
Assert.AreEqual(new Card(Rank.Nine, Suit.Heart), PokerHandArray[11].Hand[0]);
Assert.AreEqual(new Card(Rank.Nine, Suit.Spade), PokerHandArray[11].Hand[1]);
Assert.AreEqual(new Card(Rank.Nine, Suit.Diamond), PokerHandArray[11].Hand[2]);
Assert.AreEqual(new Card(Rank.Four, Suit.Spade), PokerHandArray[11].Hand[3]);
Assert.AreEqual(new Card(Rank.Four, Suit.Diamond), PokerHandArray[11].Hand[4]);
Assert.AreEqual(new Card(Rank.Nine, Suit.Heart), PokerHandArray[11].Hand[0]);
Assert.AreEqual(new Card(Rank.Nine, Suit.Spade), PokerHandArray[11].Hand[1]);
Assert.AreEqual(new Card(Rank.Nine, Suit.Diamond), PokerHandArray[11].Hand[2]);
Assert.AreEqual(new Card(Rank.Four, Suit.Spade), PokerHandArray[11].Hand[3]);
Assert.AreEqual(new Card(Rank.Four, Suit.Diamond), PokerHandArray[11].Hand[4]);
Assert.AreEqual(new Card(Rank.Eight, Suit.Spade), PokerHandArray[12].Hand[0]);
Assert.AreEqual(new Card(Rank.Seven, Suit.Club), PokerHandArray[12].Hand[1]);
Assert.AreEqual(new Card(Rank.Six, Suit.Club), PokerHandArray[12].Hand[2]);
Assert.AreEqual(new Card(Rank.Five, Suit.Club), PokerHandArray[12].Hand[3]);
Assert.AreEqual(new Card(Rank.Four, Suit.Club), PokerHandArray[12].Hand[4]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Heart), PokerHandArray[13].Hand[0]);
Assert.AreEqual(new Card(Rank.King, Suit.Diamond), PokerHandArray[13].Hand[1]);
Assert.AreEqual(new Card(Rank.Jack, Suit.Club), PokerHandArray[13].Hand[2]);
Assert.AreEqual(new Card(Rank.Seven, Suit.Club), PokerHandArray[13].Hand[3]);
Assert.AreEqual(new Card(Rank.Six, Suit.Diamond), PokerHandArray[13].Hand[4]);
Assert.AreEqual(new Card(Rank.King, Suit.Diamond), PokerHandArray[14].Hand[0]);
Assert.AreEqual(new Card(Rank.Jack, Suit.Diamond), PokerHandArray[14].Hand[1]);
Assert.AreEqual(new Card(Rank.Ten, Suit.Diamond), PokerHandArray[14].Hand[2]);
Assert.AreEqual(new Card(Rank.Nine, Suit.Diamond), PokerHandArray[14].Hand[3]);
Assert.AreEqual(new Card(Rank.Seven, Suit.Diamond), PokerHandArray[14].Hand[4]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Club), PokerHandArray[15].Hand[0]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Spade), PokerHandArray[15].Hand[1]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Diamond), PokerHandArray[15].Hand[2]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Heart), PokerHandArray[15].Hand[3]);
Assert.AreEqual(new Card(Rank.King, Suit.Spade), PokerHandArray[15].Hand[4]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Club), PokerHandArray[16].Hand[0]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Heart), PokerHandArray[16].Hand[1]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Spade), PokerHandArray[16].Hand[2]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Heart), PokerHandArray[16].Hand[3]);
Assert.AreEqual(new Card(Rank.Eight, Suit.Heart), PokerHandArray[16].Hand[4]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Club), PokerHandArray[17].Hand[0]);
Assert.AreEqual(new Card(Rank.King, Suit.Club), PokerHandArray[17].Hand[1]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Club), PokerHandArray[17].Hand[2]);
Assert.AreEqual(new Card(Rank.Jack, Suit.Club), PokerHandArray[17].Hand[3]);
Assert.AreEqual(new Card(Rank.Ten, Suit.Club), PokerHandArray[17].Hand[4]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Club), PokerHandArray[18].Hand[0]);
Assert.AreEqual(new Card(Rank.King, Suit.Club), PokerHandArray[18].Hand[1]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Club), PokerHandArray[18].Hand[2]);
Assert.AreEqual(new Card(Rank.Jack, Suit.Club), PokerHandArray[18].Hand[3]);
Assert.AreEqual(new Card(Rank.Ten, Suit.Club), PokerHandArray[18].Hand[4]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Club), PokerHandArray[19].Hand[0]);
Assert.AreEqual(new Card(Rank.King, Suit.Club), PokerHandArray[19].Hand[1]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Club), PokerHandArray[19].Hand[2]);
Assert.AreEqual(new Card(Rank.Jack, Suit.Club), PokerHandArray[19].Hand[3]);
Assert.AreEqual(new Card(Rank.Ten, Suit.Club), PokerHandArray[19].Hand[4]);
Assert.AreEqual(new Card(Rank.Ace, Suit.Club), PokerHandArray[20].Hand[0]);
Assert.AreEqual(new Card(Rank.King, Suit.Club), PokerHandArray[20].Hand[1]);
Assert.AreEqual(new Card(Rank.Queen, Suit.Club), PokerHandArray[20].Hand[2]);
Assert.AreEqual(new Card(Rank.Jack, Suit.Club), PokerHandArray[20].Hand[3]);
Assert.AreEqual(new Card(Rank.Ten, Suit.Club), PokerHandArray[20].Hand[4]);
}
public static Results ParseFromHH(String hh, bool completeSimulation, bool includeHero)
{
Environment.CurrentDirectory = Path.GetDirectoryName(Application.ExecutablePath);
Dictionary <String, IHand> hands = new Dictionary <String, IHand>();
Board board = new Board();
Dictionary <String, double> stackSizes = new Dictionary <String, double>();
ArrayList seatsInHand = new ArrayList();
Dictionary <String, String> playerNames = new Dictionary <String, String>();
Dictionary <String, String> playerSeats = new Dictionary <String, String>();
double totalBet = 0;
Consts.GameTypes gameType;
String heroName = String.Empty;
String heroCards = String.Empty;
StringReader reader = new StringReader(hh);
try
{
double currentBet = 0;
String nextLine = reader.ReadLine();
while (nextLine == String.Empty)
{
nextLine = reader.ReadLine();
}
//determine Game
if (nextLine.Contains("Omaha") || nextLine.Contains("OMAHA"))
{
if (nextLine.Contains("/L"))
{
gameType = Consts.GameTypes.OmahaHiLo;
}
else
{
gameType = Consts.GameTypes.Omaha;
}
}
else if (nextLine.Contains("Hold") || nextLine.Contains("HOLD"))
{
gameType = Consts.GameTypes.Holdem;
}
else
{
//for Seals with Clubs, game type is on second line
nextLine = reader.ReadLine();
if (nextLine.Contains("Omaha"))
{
if (nextLine.Contains("Hi-Lo"))
{
gameType = Consts.GameTypes.OmahaHiLo;
}
else
{
gameType = Consts.GameTypes.Omaha;
}
}
else if (nextLine.Contains("Hold"))
{
gameType = Consts.GameTypes.Holdem;
}
else
{
throw new Exception("Could not detect valid game type.");
}
}
//start loop to read HH
nextLine = reader.ReadLine();
//loop to read players at table and stack sizes
while (!nextLine.Contains("big blind"))
{
if (nextLine.StartsWith("Seat "))
{
String seatNumber;
int nameStartIndex;
if (nextLine.Contains(":"))
{
//Full Tilt, Stars, Seals
seatNumber = nextLine.Substring(5, nextLine.IndexOf(':') - 5);
nameStartIndex = nextLine.IndexOf(": ") + 2;
}
else
{
//AP
seatNumber = nextLine.Substring(5, nextLine.IndexOf(" - ") - 5);
nameStartIndex = nextLine.IndexOf(" - ") + 3;
}
//this is first time we've seen "Seat ", so this is chip count and name
int nameEndIndex = nextLine.IndexOf(" (", 8);
String chipCount = nextLine.Substring(nameEndIndex + 2,
nextLine.IndexOf(")", 10) - nextLine.IndexOf(" (", 8) - 2);
chipCount = chipCount.Replace("$", "");
if (chipCount.Contains(" "))
{
chipCount = chipCount.Remove(chipCount.IndexOf(" "));
}
stackSizes.Add(seatNumber, Double.Parse(chipCount));
String name = nextLine.Substring(nameStartIndex, nameEndIndex - nameStartIndex);
playerNames.Add(seatNumber, name);
playerSeats.Add(name, seatNumber);
}
nextLine = reader.ReadLine();
}
if (nextLine.Contains("big blind of ")) //Full Tilt
{
String bet = nextLine.Substring(nextLine.IndexOf("big blind of ") + "big blind of ".Length);
bet = bet.Replace("$", "");
double.TryParse(bet, out currentBet);
nextLine = reader.ReadLine();
}
else //Pokerstars, AP, Seals
{
String bet = nextLine.Substring(nextLine.IndexOf("big blind ") + "big blind ".Length);
bet = bet.Replace("$", "");
double.TryParse(bet, out currentBet);
nextLine = reader.ReadLine();
/*if (nextLine.Contains("sitout (wait for BB)"))
* {
* String sitoutName = nextLine.Substring(0, nextLine.IndexOf(" - "));
* foreach (KeyValuePair<String, String> playerName in playerNames)
* if (playerName.Value.Equals(sitoutName))
* stackSizes.Remove(playerName.Key);
* nextLine = reader.ReadLine();
* }*/
}
//loop to read board and betting action
while (!nextLine.StartsWith("Seat ") && !nextLine.StartsWith("** Pot"))
{
if (nextLine.Contains(" raises ") || nextLine.Contains(" Raise ") || nextLine.Contains(" Raises "))
{
String bet = nextLine.Substring(nextLine.IndexOf(" to ") + 4);
bet = bet.Replace("$", "");
if (bet.Contains(", and is"))
{
bet = bet.Remove(bet.IndexOf(", and is"));
}
else if (bet.Contains(" and is"))
{
bet = bet.Remove(bet.IndexOf(" and is"));
}
else if (bet.Contains("(All-in)")) //Seals
{
bet = bet.Remove(bet.IndexOf(" ( All-in)"));
}
double.TryParse(bet, out currentBet);
}
else if (nextLine.Contains(" bets ") || nextLine.Contains(" Bets "))
{
String bet;
if (nextLine.Contains(" bets "))
{
bet = nextLine.Substring(nextLine.IndexOf(" bets ") + 6);
}
else
{
bet = nextLine.Substring(nextLine.IndexOf(" Bets ") + 6);
}
bet = bet.Replace("$", "");
if (bet.Contains(", and is"))
{
bet = bet.Remove(bet.IndexOf(", and is"));
}
else if (bet.Contains(" and is "))
{
bet = bet.Remove(bet.IndexOf(" and is"));
}
else if (bet.Contains("(All-in)")) //Seals
{
bet = bet.Remove(bet.IndexOf(" ( All-in)"));
}
double.TryParse(bet, out currentBet);
}
else if (nextLine.Contains("All-In"))
{
String bet = nextLine.Substring(nextLine.IndexOf("All-In ") + 7);
bet = bet.Replace("$", "");
double tempCurrentBet = currentBet;
if (!double.TryParse(bet, out currentBet))
{
if (nextLine.Contains("All-In(Raise) "))
{
bet = nextLine.Substring(nextLine.IndexOf("All-In(Raise) "));
bet = bet.Substring(bet.IndexOf("to ") + 3);
bet = bet.Replace("$", "");
double.TryParse(bet, out currentBet);
}
}
if (tempCurrentBet > currentBet)
{
currentBet = tempCurrentBet;
}
}
else if (nextLine.StartsWith("*** F"))
{
nextLine = nextLine.Replace("10", "T");
board.Add(Card.Parse(nextLine.Substring(14, 2)));
board.Add(Card.Parse(nextLine.Substring(17, 2)));
board.Add(Card.Parse(nextLine.Substring(20, 2)));
totalBet += currentBet;
currentBet = 0;
}
else if (nextLine.StartsWith("*** T"))
{
nextLine = nextLine.Replace("10", "T");
board.Add(Card.Parse(nextLine.Substring(25, 2)));
totalBet += currentBet;
currentBet = 0;
}
else if (nextLine.StartsWith("*** R"))
{
nextLine = nextLine.Replace("10", "T");
board.Add(Card.Parse(nextLine.Substring(29, 2)));
totalBet += currentBet;
currentBet = 0;
}
else if (nextLine.StartsWith("** F")) //Seals
{
board.Add(Card.Parse(nextLine.Substring(12, 2)));
board.Add(Card.Parse(nextLine.Substring(15, 2)));
board.Add(Card.Parse(nextLine.Substring(18, 2)));
totalBet += currentBet;
currentBet = 0;
}
else if (nextLine.StartsWith("** T")) //Seals
{
board.Add(Card.Parse(nextLine.Substring(12, 2)));
totalBet += currentBet;
currentBet = 0;
}
else if (nextLine.StartsWith("** R")) //Seals
{
board.Add(Card.Parse(nextLine.Substring(13, 2)));
totalBet += currentBet;
currentBet = 0;
}
else if (nextLine.StartsWith("Uncalled bet "))
{
if (nextLine.Contains(" of "))
{
//for Full Tilt HH
String returnedBet = nextLine.Substring(16, nextLine.IndexOf(" returned") - 16);
returnedBet = returnedBet.Replace("$", "");
currentBet -= Double.Parse(returnedBet);
}
else
{
//for PS HH
String returnedBet = nextLine.Substring(14, nextLine.IndexOf(")") - 14);
returnedBet = returnedBet.Replace("$", "");
currentBet -= Double.Parse(returnedBet);
}
}
else if (nextLine.Contains("returned ("))
{
//for AP HH
int returnedBetStartIndex = nextLine.IndexOf("(") + 1;
int returnedBetEndIndex = nextLine.IndexOf(")");
String returnedBet = nextLine.Substring(returnedBetStartIndex, returnedBetEndIndex - returnedBetStartIndex);
returnedBet = returnedBet.Replace("$", "");
currentBet -= Double.Parse(returnedBet);
}
else if (nextLine.Contains("refunded "))
{
//Seals
int returnedBetStartIndex = nextLine.IndexOf("refunded ") + "refunded ".Length;
String returnedBet = nextLine.Substring(returnedBetStartIndex);
currentBet -= Double.Parse(returnedBet);
}
else if (nextLine.StartsWith("Dealt to "))
{
heroName = nextLine.Substring("Dealt to ".Length);
heroCards = heroName.Substring(heroName.IndexOf(" [") + 2);
heroName = heroName.Remove(heroName.IndexOf(" ["));
heroCards = heroCards.Remove(heroCards.IndexOf(']'));
}
nextLine = reader.ReadLine();
}
totalBet += currentBet;
if (nextLine.Contains("Seat "))
{
//loop to read showdown
while (nextLine.StartsWith("Seat "))
{
String seatNumber = nextLine.Substring(5, nextLine.IndexOf(':') - 5);
try
{
//this is second time we've seen "Seat ", so this is showdown
if (playerNames[seatNumber].Equals(heroName) && includeHero)
{
stackSizes[seatNumber] = double.MaxValue;
if (gameType == Consts.GameTypes.Holdem)
{
hands.Add(seatNumber, HoldemHand.Parse(heroCards));
}
else
{
hands.Add(seatNumber, OmahaHand.Parse(heroCards));
}
}
//else if (nextLine.Contains("showed") || nextLine.Contains("mucked"))
else if (nextLine.Contains("["))
{
int index;
nextLine = nextLine.Replace("10", "T");
if (nextLine.Contains("[Mucked]"))
{
index = nextLine.IndexOf("[", nextLine.IndexOf("[") + 1);
}
else
{
index = nextLine.IndexOf("[");
}
if (gameType == Consts.GameTypes.Holdem)
{
hands.Add(seatNumber, HoldemHand.Parse(nextLine.Substring(index + 1, 5)));
}
else
{
hands.Add(seatNumber, OmahaHand.Parse(nextLine.Substring(index + 1, 11)));
}
seatsInHand.Add(seatNumber);
}
else
{
stackSizes.Remove(seatNumber);
}
}
catch (Exception)
{
//player might have sat in previous round and bought in this round
//this causes a bug in some FT HHs
nextLine = nextLine.Substring(nextLine.Substring(1).IndexOf("Seat") + 1);
nextLine = nextLine.Replace("10", "T");
int tempSeatNumber = Int32.Parse(seatNumber);
tempSeatNumber++;
seatNumber = tempSeatNumber.ToString();
if (nextLine.Contains("["))
{
int index = nextLine.IndexOf("[");
if (gameType == Consts.GameTypes.Holdem)
{
hands.Add(seatNumber, HoldemHand.Parse(nextLine.Substring(index + 1, 5)));
}
else
{
hands.Add(seatNumber, OmahaHand.Parse(nextLine.Substring(index + 1, 11)));
}
}
else
{
stackSizes.Remove(seatNumber);
}
}
nextLine = reader.ReadLine();
if (nextLine == null)
{
break;
}
}
}
else if (nextLine.StartsWith("** Pot"))
{
//Seals, different showdown format
nextLine = reader.ReadLine();
while (nextLine.Contains("shows"))
{
String playerName = nextLine.Substring(0, nextLine.IndexOf(" shows"));
String seatNumber = playerSeats[playerName];
if (playerName.Equals(heroName) && includeHero)
{
stackSizes[seatNumber] = double.MaxValue;
if (gameType == Consts.GameTypes.Holdem)
{
hands.Add(seatNumber, HoldemHand.Parse(heroCards));
}
else
{
hands.Add(seatNumber, OmahaHand.Parse(heroCards));
}
}
else if (nextLine.Contains("["))
{
int index = nextLine.IndexOf("[");
if (gameType == Consts.GameTypes.Holdem)
{
hands.Add(seatNumber, HoldemHand.Parse(nextLine.Substring(index + 1, 5)));
}
else
{
hands.Add(seatNumber, OmahaHand.Parse(nextLine.Substring(index + 1, 11)));
}
seatsInHand.Add(seatNumber);
}
nextLine = reader.ReadLine();
}
}
}
catch (CardException e)
{
if (e.CardString.Equals("Do"))
{
return(new Results("Error parsing hand history. At least two shown hands are required for simulation.", hh));
}
else
{
return(new Results("Error parsing hand history. Could not parse card '" + e.CardString + "'", hh));
}
}
catch (Exception)
{
return(new Results("Error parsing hand history.", hh));
}
if (board.Cards.Count != 5)
{
return(new Results("Error parsing hand history. There must be five board cards.", hh));
}
else if (hands.Count < 2)
{
return(new Results("Error parsing hand history. At least two shown hands are required for simulation.", hh));
}
Deck deck = new Deck();
ArrayList handsArrayList = new ArrayList(hands.Values);
deck.RemoveHands(handsArrayList);
Calculator calc = new Calculator(deck, handsArrayList, board, gameType);
Results results = new Results(gameType, board, hh);
if (hands.Count < stackSizes.Count)
{
ArrayList seatsToRemove = new ArrayList();
foreach (KeyValuePair <String, double> stackSize in stackSizes)
{
if (!seatsInHand.Contains(stackSize.Key))
{
seatsToRemove.Add(stackSize.Key);
}
}
foreach (String seatToRemove in seatsToRemove)
{
stackSizes.Remove(seatToRemove);
}
}
//create results summary
String summary = "";
double smallStack = totalBet;
foreach (KeyValuePair <String, double> stackSize in stackSizes)
{
summary += ((IHand)hands[stackSize.Key]).Cards.ToString(false) + " v ";
((IHand)hands[stackSize.Key]).ChipCount = stackSize.Value;
((IHand)hands[stackSize.Key]).PlayerName = playerNames[stackSize.Key];
if (((IHand)hands[stackSize.Key]).ChipCount < smallStack)
{
smallStack = ((IHand)hands[stackSize.Key]).ChipCount;
}
}
summary = summary.Remove(summary.Length - 3);
results.Summary = summary;
DateTime startTime = DateTime.Now;
bool sidePot;
do
{
sidePot = false;
//Calculate Equities
double[] preflopEquities = calc.CalculatePreflopEquity();
double[] flopEquities = calc.CalculateFlopEquity();
double[] turnEquities = calc.CalculateTurnEquity();
double[] riverEquities = calc.CalculateRiverEquity();
Simulation simulation = new Simulation((IHand[])handsArrayList.ToArray(typeof(IHand)), preflopEquities, flopEquities, turnEquities, riverEquities);
results.AddSimulation(simulation);
if (smallStack < (totalBet - .009))
{
double tempSmallStack = smallStack;
ArrayList tempHands = (ArrayList)handsArrayList.Clone();
smallStack = totalBet;
foreach (IHand hand in tempHands)
{
if (hand.ChipCount == tempSmallStack)
{
handsArrayList.Remove(hand);
if (hands.Count > 1)
{
sidePot = true;
}
}
else if (hand.ChipCount < smallStack)
{
smallStack = hand.ChipCount;
}
}
calc.Deck = deck;
}
} while (sidePot && completeSimulation);
TimeSpan totalTime = DateTime.Now - startTime;
results.Time = totalTime.TotalSeconds;
return(results);
}
