public void TestIsFlushFiveDifferentFaceEaqualSuitsNotSerial()
{
IList<ICard> cards = new List<ICard>();
Card card1 = new Card(CardFace.Ace, CardSuit.Spades);
cards.Add(card1);
Card card2 = new Card(CardFace.Ten, CardSuit.Spades);
cards.Add(card2);
Card card3 = new Card(CardFace.Queen, CardSuit.Spades);
cards.Add(card3);
Card card4 = new Card(CardFace.Jack, CardSuit.Spades);
cards.Add(card4);
Card card5 = new Card(CardFace.Seven, CardSuit.Spades);
cards.Add(card5);
Hand hand = new Hand(cards);
PokerHandsChecker checker = new PokerHandsChecker();
bool actual = checker.IsFlush(hand);
bool expected = true;
Assert.AreEqual(expected, actual);
}
public override HandRanking Catagorize(Hand hand)
{
Dictionary<Value, int> seen = new Dictionary<Value, int>();
foreach (Card c in hand.Cards)
{
if (seen.ContainsKey(c.Value))
{
seen[c.Value]++;
}
else
{
seen[c.Value] = 1;
}
}
if (seen.Count == 2)
{
if(seen.ContainsValue(3) && seen.ContainsValue(2))
{
return HandRanking.FullHouse;
}
}
return Next.Catagorize(hand);
}
public void TestHandToStringWithEmptyCardsSet()
{
var cards = new List <ICard>();
var hand = new Poker.Hand(cards);
Assert.AreEqual("[]", hand.ToString());
}
public void TestSeveralHands()
{
IList<ICard> cardCollection = new List<ICard>();
Random getValue = new Random();
string randomValue;
string randomSuit;
for (int i = 0; i < 5; i++)
{
randomValue = values[getValue.Next(0, values.Length - 1)];
randomSuit = suits[getValue.Next(0, suits.Length - 1)];
Card current = CardGenerator.Generate(randomValue, randomSuit);
if (!cardCollection.Contains(current))
{
cardCollection.Add(current);
}
else
{
i--;
}
}
Hand cards = new Hand(cardCollection);
Assert.AreEqual(string.Join(", ", cardCollection), cards.ToString());
}
public void PokerHandsChecker_IsThreeOfAKind_ContainsLessThanThreeCardsWithSameFace_ShouldBe_False()
{
var currentHand = new Hand(cards);
currentHand.Cards.RemoveAt(0);
Assert.IsFalse(checker.IsThreeOfAKind(currentHand));
}
public void NumberOfCardsInHandMastBeExactFive()
{
IList<ICard> cards = GenerateCorectCards();
cards.RemoveAt(4);
Hand hand = new Hand(cards);
}
public void TestCompareHandsFirstHand()
{
Card cardOne = new Card(CardFace.Ace, CardSuit.Diamonds);
Card cardTwo = new Card(CardFace.Ace, CardSuit.Hearts);
Card cardThree = new Card(CardFace.Five, CardSuit.Spades);
Card cardFour = new Card(CardFace.Ace, CardSuit.Clubs);
Card cardFive = new Card(CardFace.Ace, CardSuit.Spades);
IList<ICard> cardsOne = new List<ICard>();
cardsOne.Add(cardOne);
cardsOne.Add(cardTwo);
cardsOne.Add(cardThree);
cardsOne.Add(cardFour);
cardsOne.Add(cardFive);
Hand handOne = new Hand(cardsOne);
Card cardSix = new Card(CardFace.Two, CardSuit.Diamonds);
Card cardSeven = new Card(CardFace.Jack, CardSuit.Hearts);
Card cardEight = new Card(CardFace.Five, CardSuit.Spades);
Card cardNine = new Card(CardFace.Ace, CardSuit.Clubs);
Card cardTen = new Card(CardFace.Ten, CardSuit.Clubs);
IList<ICard> cardsTwo = new List<ICard>();
cardsTwo.Add(cardSix);
cardsTwo.Add(cardSeven);
cardsTwo.Add(cardEight);
cardsTwo.Add(cardNine);
cardsTwo.Add(cardTen);
Hand handTwo = new Hand(cardsTwo);
PokerHandsChecker poker = new PokerHandsChecker();
int result = poker.CompareHands(handOne, handTwo);
Assert.AreEqual(1, result, "CompareHands() method in class PokerHandsChecker is not working correctly.");
}
internal static void Main()
{
ICard card = new Card(CardFace.Ace, CardSuit.Clubs);
Console.WriteLine(card);
IHand hand = new Hand(new List<ICard>()
{
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.King, CardSuit.Hearts),
new Card(CardFace.King, CardSuit.Spades),
new Card(CardFace.Seven, CardSuit.Diamonds),
});
Console.WriteLine(hand);
IPokerHandsChecker checker = new PokerHandsChecker();
Console.WriteLine(checker.IsValidHand(hand));
Console.WriteLine(checker.IsOnePair(hand));
Console.WriteLine(checker.IsTwoPairs(hand));
int a = 5;
int b = 6;
Console.WriteLine(b.CompareTo(a));
}
static void Main()
{
ICard card = new Card(CardFace.Ace, CardSuit.Clubs);
Console.WriteLine(card);
IHand hand = new Hand(new List<ICard>() {
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.King, CardSuit.Hearts),
new Card(CardFace.King, CardSuit.Spades),
new Card(CardFace.Seven, CardSuit.Diamonds),
});
Console.WriteLine(hand);
IPokerHandsChecker checker = new PokerHandsChecker();
Console.WriteLine(checker.IsValidHand(hand));
Console.WriteLine(checker.IsOnePair(hand));
Console.WriteLine(checker.IsTwoPair(hand));
var card1 = new Card(CardFace.Jack, CardSuit.Clubs);
var card2 = new Card(CardFace.Nine, CardSuit.Diamonds);
var card3 = new Card(CardFace.Four, CardSuit.Spades);
var card4 = new Card(CardFace.Two, CardSuit.Hearts);
var card5 = new Card(CardFace.Queen, CardSuit.Hearts);
var hand2 = new Hand(new List<ICard> { card1, card2, card3, card4, card5 });
Console.WriteLine(hand2);
}
public void TestAllPossibleFourOfAKindHands()
{
IList<ICard> fourOfAKindCollection = new List<ICard>();
byte countOfAllValues = 13;
byte countOfAllKinds = 4;
Hand playerHand;
List<bool> results = new List<bool>();
int faceOfAdditionalCard;
for (int i = 0; i < countOfAllValues; i++)
{
faceOfAdditionalCard = i;
for (int j = 1; j <= countOfAllKinds; j++)
{
fourOfAKindCollection.Add(new Card((CardFace)i + 2, (CardSuit)j));
}
if (faceOfAdditionalCard + 3 > 14)
{
faceOfAdditionalCard = 2;
}
fourOfAKindCollection.Add(new Card((CardFace)faceOfAdditionalCard + 3, CardSuit.Hearts));
playerHand = new Hand(fourOfAKindCollection);
results.Add(this.checker.IsFourOfAKind(playerHand));
fourOfAKindCollection.Clear();
}
byte countOfAllTrueResults = (byte)results.Count(res => res == true);
Assert.AreEqual(results.Count, countOfAllTrueResults);
}
public void CompareHands_EqualFlushes()
{
IList<ICard> firstHandCards = new List<ICard>
{
new Card(CardFace.Queen, CardSuit.Hearts),
new Card(CardFace.Ten, CardSuit.Hearts),
new Card(CardFace.Seven, CardSuit.Hearts),
new Card(CardFace.Five, CardSuit.Hearts),
new Card(CardFace.Three, CardSuit.Hearts),
};
IList<ICard> secondHandCards = new List<ICard>
{
new Card(CardFace.Queen, CardSuit.Clubs),
new Card(CardFace.Ten, CardSuit.Clubs),
new Card(CardFace.Seven, CardSuit.Clubs),
new Card(CardFace.Five, CardSuit.Clubs),
new Card(CardFace.Three, CardSuit.Clubs),
};
Hand firstHand = new Hand(firstHandCards);
Hand secondHand = new Hand(secondHandCards);
PokerHandsChecker checker = new PokerHandsChecker();
int expected = 0;
int actual = checker.CompareHands(firstHand, secondHand);
Assert.AreEqual(expected, actual);
}
public void HighCardTrueTest()
{
var card1 = new Card(CardFace.King, CardSuit.Hearts);
var card2 = new Card(CardFace.Five, CardSuit.Spades);
var card3 = new Card(CardFace.Seven, CardSuit.Diamonds);
var card4 = new Card(CardFace.Ten, CardSuit.Clubs);
var card5 = new Card(CardFace.Two, CardSuit.Spades);
var cards = new List<ICard>();
cards.Add(card1);
cards.Add(card2);
cards.Add(card3);
cards.Add(card4);
cards.Add(card5);
// ♣
// ♦
// ♥
// ♠
Hand hand = new Hand(cards);
bool expected = true;
PokerHandsChecker checker = new PokerHandsChecker();
bool actual = checker.IsHighCard(hand);
Assert.AreEqual(expected, actual);
}
public void PokerHandCheckerCompareHandsStrongerToWeakerTest()
{
IList<ICard> firstCardsSet = new List<ICard>()
{
new Card(CardFace.Four, CardSuit.Clubs),
new Card(CardFace.Three, CardSuit.Clubs),
new Card(CardFace.Two, CardSuit.Clubs),
new Card(CardFace.Six, CardSuit.Clubs),
new Card(CardFace.Five, CardSuit.Clubs)
};
IList<ICard> secondCardsSet = new List<ICard>()
{
new Card(CardFace.Ten, CardSuit.Clubs),
new Card(CardFace.King, CardSuit.Spades),
new Card(CardFace.Jack, CardSuit.Hearts),
new Card(CardFace.Queen, CardSuit.Diamonds),
new Card(CardFace.Ace, CardSuit.Hearts)
};
IHand firstHand = new Hand(firstCardsSet);
IHand secondHand = new Hand(secondCardsSet);
int result = handsChecker.CompareHands(firstHand, secondHand);
int expected = 1;
Assert.AreEqual(expected, result, "Stronger hand is incorrectly compared to weaker one.");
}
public void TestEmptyHand()
{
Hand hand = new Hand(new List<ICard>());
string handToString = hand.ToString();
Assert.AreEqual(string.Empty, handToString,
"ToString() method in class Hand is not working correctly.");
}
public void CompareHands_EqualFullHouses()
{
IList<ICard> firstHandCards = new List<ICard>
{
new Card(CardFace.Six, CardSuit.Diamonds),
new Card(CardFace.Two, CardSuit.Spades),
new Card(CardFace.Two, CardSuit.Diamonds),
new Card(CardFace.Two, CardSuit.Hearts),
new Card(CardFace.Six, CardSuit.Hearts),
};
IList<ICard> secondHandCards = new List<ICard>
{
new Card(CardFace.Six, CardSuit.Diamonds),
new Card(CardFace.Two, CardSuit.Spades),
new Card(CardFace.Two, CardSuit.Diamonds),
new Card(CardFace.Two, CardSuit.Hearts),
new Card(CardFace.Six, CardSuit.Hearts),
};
Hand firstHand = new Hand(firstHandCards);
Hand secondHand = new Hand(secondHandCards);
PokerHandsChecker checker = new PokerHandsChecker();
int expected = 0;
int actual = checker.CompareHands(firstHand, secondHand);
Assert.AreEqual(expected, actual);
}
public void CompareHands_OneOnTwoPairsFirstWithHigherKicker()
{
IList<ICard> cardsFirstHand = new List<ICard>();
cardsFirstHand.Add(new Card(CardFace.Ace, CardSuit.Diamonds));
cardsFirstHand.Add(new Card(CardFace.Four, CardSuit.Spades)); // kicker 1 (higher)
cardsFirstHand.Add(new Card(CardFace.King, CardSuit.Spades));
cardsFirstHand.Add(new Card(CardFace.Ace, CardSuit.Clubs));
cardsFirstHand.Add(new Card(CardFace.King, CardSuit.Hearts));
IHand firstHand = new Hand(cardsFirstHand);
IList<ICard> cardsSecondHand = new List<ICard>();
cardsSecondHand.Add(new Card(CardFace.Ace, CardSuit.Hearts));
cardsSecondHand.Add(new Card(CardFace.King, CardSuit.Diamonds));
cardsSecondHand.Add(new Card(CardFace.King, CardSuit.Clubs));
cardsSecondHand.Add(new Card(CardFace.Ace, CardSuit.Spades));
cardsSecondHand.Add(new Card(CardFace.Three, CardSuit.Hearts)); // kicker 2
IHand secondHand = new Hand(cardsSecondHand);
PokerHandsChecker checker = new PokerHandsChecker();
int result = checker.CompareHands(firstHand, secondHand);
Assert.AreEqual(1, result);
}
public void CompareHands_MinusOneOnSteelWheelAndHigherStraight()
{
IList<ICard> cardsFirstHand = new List<ICard>();
cardsFirstHand.Add(new Card(CardFace.Five, CardSuit.Clubs));
cardsFirstHand.Add(new Card(CardFace.Ace, CardSuit.Spades));
cardsFirstHand.Add(new Card(CardFace.Two, CardSuit.Diamonds));
cardsFirstHand.Add(new Card(CardFace.Four, CardSuit.Spades));
cardsFirstHand.Add(new Card(CardFace.Three, CardSuit.Hearts));
IHand firstHand = new Hand(cardsFirstHand);
IList<ICard> cardsSecondHand = new List<ICard>();
cardsSecondHand.Add(new Card(CardFace.Seven, CardSuit.Diamonds));
cardsSecondHand.Add(new Card(CardFace.Five, CardSuit.Spades));
cardsSecondHand.Add(new Card(CardFace.Four, CardSuit.Diamonds));
cardsSecondHand.Add(new Card(CardFace.Three, CardSuit.Clubs));
cardsSecondHand.Add(new Card(CardFace.Six, CardSuit.Hearts));
IHand secondHand = new Hand(cardsSecondHand);
PokerHandsChecker checker = new PokerHandsChecker();
int result = checker.CompareHands(firstHand, secondHand);
Assert.AreEqual(-1, result);
}
static void Main()
{
Console.BackgroundColor = ConsoleColor.White;
Console.ForegroundColor = ConsoleColor.Black;
ICard card = new Card(CardFace.Ace, CardSuit.Clubs);
Console.WriteLine(card);
IHand hand = new Hand(new List<ICard>()
{
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.King, CardSuit.Hearts),
new Card(CardFace.King, CardSuit.Spades),
new Card(CardFace.Seven, CardSuit.Diamonds),
});
IHand hand2 = new Hand(new List<ICard>()
{
new Card(CardFace.Two, CardSuit.Clubs),
new Card(CardFace.Two, CardSuit.Diamonds),
new Card(CardFace.Three, CardSuit.Hearts),
new Card(CardFace.Three, CardSuit.Spades),
new Card(CardFace.Two, CardSuit.Hearts),
});
Console.WriteLine(hand);
IPokerHandsChecker checker = new PokerHandsChecker();
Console.WriteLine("Is valid hand: " + checker.IsValidHand(hand));
Console.WriteLine("Is one pair: " + checker.IsOnePair(hand));
Console.WriteLine("Is two pairs: " + checker.IsTwoPair(hand));
Console.WriteLine(Environment.NewLine + "Compare hands. 1 for first hand. -1 for second hand. 0 for same hands");
Console.WriteLine("Hand: {0}, Hand2: {1} Compare: {2}", hand, hand2, checker.CompareHands(hand, hand2));
}
public static PokerPlay CheckPlay(Hand hand)
{
if (5 > hand.Cards.Count())
throw new NotEnoughCardsException();
var play = PokerPlay.None;
var countCardValues = GeneratePlayDictionary();
foreach (var card in hand.Cards)
{
countCardValues[card.Value]++;
}
foreach (var source in countCardValues.Where(x => x.Value == 0).Select(x => x.Key).ToArray())
{
countCardValues.Remove(source);
}
if (IsStraightFlush(hand, countCardValues)) play = PokerPlay.StraightFlush;
else if (IsFourOfAKind(countCardValues)) play = PokerPlay.FourOfAKind;
else if (IsFullHouse(countCardValues)) play = PokerPlay.FullHouse;
else if (IsFlush(hand)) play = PokerPlay.Flush;
else if (IsStraight(countCardValues)) play = PokerPlay.Straight;
else if (IsThreeOfAKind(countCardValues)) play = PokerPlay.ThreeOfAKind;
else if (IsTwoPairs(countCardValues)) play = PokerPlay.TwoPair;
else if (IsPair(countCardValues)) play = PokerPlay.Pair;
return play;
}
public void CompareHands_MinusOneOnSimilarThrees()
{
IList<ICard> cardsFirstHand = new List<ICard>();
cardsFirstHand.Add(new Card(CardFace.Eight, CardSuit.Clubs)); // kicker 1
cardsFirstHand.Add(new Card(CardFace.Four, CardSuit.Spades));
cardsFirstHand.Add(new Card(CardFace.Four, CardSuit.Diamonds));
cardsFirstHand.Add(new Card(CardFace.Four, CardSuit.Clubs));
cardsFirstHand.Add(new Card(CardFace.Seven, CardSuit.Diamonds)); // kicker 2
IHand firstHand = new Hand(cardsFirstHand);
IList<ICard> cardsSecondHand = new List<ICard>();
cardsSecondHand.Add(new Card(CardFace.Four, CardSuit.Diamonds));
cardsSecondHand.Add(new Card(CardFace.Four, CardSuit.Spades));
cardsSecondHand.Add(new Card(CardFace.Nine, CardSuit.Diamonds)); // kicker 1
cardsSecondHand.Add(new Card(CardFace.Two, CardSuit.Clubs));
cardsSecondHand.Add(new Card(CardFace.Four, CardSuit.Clubs)); // kicker 2
IHand secondHand = new Hand(cardsSecondHand);
PokerHandsChecker checker = new PokerHandsChecker();
int result = checker.CompareHands(firstHand, secondHand);
Assert.AreEqual(-1, result);
}
public void PokerTestToStringWithOneCardTenSpades()
{
Card tenSpades = new Card(CardFace.Ten, CardSuit.Spades);
Hand hand = new Hand(new List<ICard>{ tenSpades });
string result = hand.ToString();
Assert.AreEqual("10♠", result);
}
public void TestHand()
{
var card1 = new Card(CardFace.King, CardSuit.Hearts);
var card2 = new Card(CardFace.Five, CardSuit.Spades);
var card3 = new Card(CardFace.Seven, CardSuit.Diamonds);
var card4 = new Card(CardFace.Ten, CardSuit.Clubs);
var card5 = new Card(CardFace.Two, CardSuit.Spades);
var cards = new List<ICard>();
cards.Add(card1);
cards.Add(card2);
cards.Add(card3);
cards.Add(card4);
cards.Add(card5);
// ♣
// ♦
// ♥
// ♠
Hand hand = new Hand(cards);
string expected = "K♥5♠7♦10♣2♠";
string actual = hand.ToString();
Assert.AreEqual(expected, actual);
}
public HandInfo(Hand h, IEnumerable<Card> wilds)
{
if (wilds == null || wilds.Count() == 0)
{
wildCards = new Card[0];
}
else
{
wildCards = wilds.ToArray();
}
hcsUnbound = h.Cards.Where(hc => hc.IsJoker() || IsWild(hc)).ToArray();
hcsPlain = h.Cards.Except(hcsUnbound).ToArray();
var suitHistolist = hcsPlain
.GroupBy(hc => hc.Suit)
.Select(grp => new { Suit = grp.Key, Count = grp.Count() })
.OrderByDescending(grp => grp.Count).ToList();
suitGram = new Dictionary<TSuit, int>();
foreach (var suitData in suitHistolist) {
suitGram[suitData.Suit] = suitData.Count;
}
var valueHistolist = hcsPlain
.GroupBy(hc => hc.Value)
.Select(grp => new { Value = grp.Key, Count = grp.Count() })
.OrderByDescending(grp => grp.Count).ToList();
valueGram = new Dictionary<TValue, int>();
foreach (var valueData in valueHistolist) {
valueGram[valueData.Value] = valueData.Count;
}
}
public void FullHouseHandTest()
{
var kingOfClubs = new Card(CardFace.King, CardSuit.Clubs);
var kingOfSpades = new Card(CardFace.King, CardSuit.Spades);
var kingOfHearths = new Card(CardFace.King, CardSuit.Hearts);
var jackOfDiamonds = new Card(CardFace.Jack, CardSuit.Diamonds);
var jackOfSpades = new Card(CardFace.Jack, CardSuit.Spades);
IList<ICard> cards = new List<ICard>()
{
kingOfClubs,
kingOfSpades,
kingOfHearths,
jackOfDiamonds,
jackOfSpades
};
var hand = new Hand(cards);
var expectedResult = kingOfClubs.ToString() + ", " +
kingOfSpades.ToString() + ", " +
kingOfHearths.ToString() + ", " +
jackOfDiamonds.ToString() + ", " +
jackOfSpades.ToString();
Assert.AreEqual(expectedResult, hand.ToString());
}
public void TestOrderHandSameCards()
{
Card cardOne = new Card(CardFace.Two, CardSuit.Diamonds);
Card cardTwo = new Card(CardFace.Jack, CardSuit.Hearts);
Card cardThree = new Card(CardFace.Five, CardSuit.Spades);
Card cardFour = new Card(CardFace.Ace, CardSuit.Clubs);
Card cardFive = new Card(CardFace.Ace, CardSuit.Diamonds);
IList<ICard> cards = new List<ICard>();
cards.Add(cardOne);
cards.Add(cardTwo);
cards.Add(cardThree);
cards.Add(cardFour);
cards.Add(cardFive);
Hand hand = new Hand(cards);
ICard[] array = hand.OrderHand();
Assert.AreEqual(cardOne.Face, array[0].Face,
"OrderHand() method in class Hand is not working correctly.");
Assert.AreEqual(cardThree.Face, array[1].Face,
"OrderHand() method in class Hand is not working correctly.");
Assert.AreEqual(cardTwo.Face, array[2].Face,
"OrderHand() method in class Hand is not working correctly.");
Assert.AreEqual(cardFour.Face, array[3].Face,
"OrderHand() method in class Hand is not working correctly.");
Assert.AreEqual(cardFour.Face, array[4].Face,
"OrderHand() method in class Hand is not working correctly.");
}
private static void Main()
{
try
{
IHand hand = new Hand(new List<ICard>()
{
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Queen, CardSuit.Clubs),
new Card(CardFace.King, CardSuit.Clubs),
new Card(CardFace.Jack, CardSuit.Clubs),
new Card(CardFace.Ten, CardSuit.Clubs),
});
Console.WriteLine(hand);
IPokerHandsChecker checker = new PokerHandsChecker();
Console.WriteLine(checker.IsValidHand(hand) ? "Hand is valid." : "Hand is not valid!");
Console.WriteLine(checker.IsRoyalFlush(hand) ? "Royal flush." : "Hand is not Royal flush!");
Console.WriteLine(checker.IsStraightFlush(hand) ? "Straight flush." : "Hand is not Straight flush!");
Console.WriteLine(checker.IsFlush(hand) ? "Flush." : "Hand is not Flush!");
Console.WriteLine(checker.IsStraight(hand) ? "Straight." : "Hand is not Straight!");
Console.WriteLine(checker.IsFullHouse(hand) ? "Full house." : "Hand is not Full house!");
Console.WriteLine(checker.IsFourOfAKind(hand) ? "Four of a kind." : "Hand is not Four of a kind!");
Console.WriteLine(checker.IsThreeOfAKind(hand) ? "Three of a kind." : "Hand is not Three of a kind!");
IHand hand1 = new Hand("K♥ J♥ 8♣ 7♦ 4♠");
Console.WriteLine(hand1);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void TestCompareHandsWithEqualFullHouseHands()
{
Card fCard1 = new Card(CardFace.Eight, CardSuit.Hearts);
Card fCard2 = new Card(CardFace.Jack, CardSuit.Hearts);
Card fCard3 = new Card(CardFace.Eight, CardSuit.Diamonds);
Card fCard4 = new Card(CardFace.Jack, CardSuit.Clubs);
Card fCard5 = new Card(CardFace.Jack, CardSuit.Spades);
Card sCard1 = new Card(CardFace.Jack, CardSuit.Diamonds);
Card sCard2 = new Card(CardFace.Eight, CardSuit.Diamonds);
Card sCard3 = new Card(CardFace.Eight, CardSuit.Spades);
Card sCard4 = new Card(CardFace.Jack, CardSuit.Clubs);
Card sCard5 = new Card(CardFace.Jack, CardSuit.Spades);
firstHandCardList = new List<ICard>();
firstHandCardList.Add(fCard1);
firstHandCardList.Add(fCard2);
firstHandCardList.Add(fCard3);
firstHandCardList.Add(fCard4);
firstHandCardList.Add(fCard5);
secondHandCardList = new List<ICard>();
secondHandCardList.Add(sCard1);
secondHandCardList.Add(sCard2);
secondHandCardList.Add(sCard3);
secondHandCardList.Add(sCard4);
secondHandCardList.Add(sCard5);
Hand firstHand = new Hand(firstHandCardList);
Hand secondHand = new Hand(secondHandCardList);
Assert.AreEqual(handsComparator.CompareHands(firstHand, secondHand), WinningHand.HandsAreEqueal);
}
static void Main()
{
ICard card = new Card(CardFace.Ace, CardSuit.Clubs);
Console.WriteLine(card);
IHand hand = new Hand(new List<ICard>() {
new Card(CardFace.Ace, CardSuit.Clubs),
new Card(CardFace.Ace, CardSuit.Diamonds),
new Card(CardFace.King, CardSuit.Hearts),
new Card(CardFace.King, CardSuit.Spades),
new Card(CardFace.Seven, CardSuit.Diamonds),
});
Console.WriteLine(hand);
IPokerHandsChecker checker = new PokerHandsChecker();
Console.WriteLine(checker.IsValidHand(hand));
Console.WriteLine(checker.IsStraight(hand));
Console.WriteLine(checker.IsOnePair(hand));
Console.WriteLine(checker.IsTwoPair(hand));
Console.WriteLine(checker.IsStraightFlush(hand));
Console.WriteLine(checker.IsFlush(hand));
Console.WriteLine(checker.IsFourOfAKind(hand));
Console.WriteLine(checker.IsThreeOfAKind(hand));
Console.WriteLine(checker.IsHighCard(hand));
Console.WriteLine(checker.IsFullHouse(hand));
}
public void TestHandToStringWithValidDeckButWrongFormatting2()
{
var cards =
(from face in _cardFaces from suit in _cardSuits select new Card(face, suit)).Cast<ICard>().ToList();
var hand = new Poker.Hand(cards);
Assert.AreNotEqual(string.Format("[{0}]", string.Join(" ,", cards)), hand.ToString());
}
public void TestHandToString1()
{
ICard[] cards = new ICard[0];
IHand hand = new Hand(cards);
Assert.AreEqual(string.Empty, hand.ToString(), "Hand constructor does not work correctly.");
}
protected static bool HasNofKind(int n, Hand hand)
{
Dictionary<Value, int> seen = new Dictionary<Value, int>();
foreach (Card c in hand.Cards)
{
if (seen.ContainsKey(c.Value))
{
seen[c.Value]++;
}
else
{
seen[c.Value] = 1;
}
}
foreach (int count in seen.Values)
{
if (count == n)
{
return true;
}
}
return false;
}
public void TestHandToStringWithValidDeckButWrongFormatting3()
{
var cards =
(from face in _cardFaces from suit in _cardSuits select new Card(face, suit)).Cast <ICard>().ToList();
var hand = new Poker.Hand(cards);
Assert.AreNotEqual(string.Format("[{0}]", string.Join(" , ", cards)), hand.ToString());
}
public void TestHandToStringWithOneCardSet()
{
var face = CardFace.Eight;
var suit = CardSuit.Diamonds;
var card = new Card(face, suit);
var cards = new List <ICard> {
card
};
var hand = new Poker.Hand(cards);
Assert.AreEqual(string.Format("[{0}]", card), hand.ToString());
}
// Do a round
public void DoRound()
{
pack.Shuffle();
Hand communityCards = new Hand();
List <Player> playersIn = new List <Player>(players); // PlayersIn are the players that haven't folded this round
int pot = 0; // Number of chips in the pot
int bet = 0; // The amount that a player must match to remain in the game
// Dealing cards to players
for (int i = 0; i < playersIn.Count; i++)
{
Draw(playersIn[i].pHand, 2);
}
bool roundOver = false;
bool playerFolded = false;
int roundNum = 0;
int[] toDeal = { 0, 2, 1, 1, 1 }; // The number of cards to deal to commCards each round
while (!roundOver)
{
// Drawing cards to the community hand
try
{
Draw(communityCards, toDeal[roundNum]);
}
catch
{
Console.WriteLine("All cards drawn...");
roundOver = true;
break;
}
roundNum++;
// Displaying information about the round if the player is still in
if (!playerFolded)
{
Console.WriteLine($"\nPOT: {pot}");
Console.WriteLine($"YOUR CHIPS: {players[0].Chips()}");
Console.Write("\nYOUR HAND: ");
players[0].pHand.DisplayHand();
Console.Write("COMMUNITY: ");
communityCards.DisplayHand(true, 5);
Console.WriteLine();
}
else
{
Console.WriteLine("You have folded...");
}
// Taking bets
for (int i = 0; i < playersIn.Count; i++)
{
Console.WriteLine($"{playersIn[i].GetName()}'s turn");
if (playersIn[i].HasChips()) // Has player gone all in or not
{
playersIn[i].SetCommCards(communityCards);
//playersIn[i].pHand.DisplayHand();
int pBet = playersIn[i].TakeBet(bet); // Returns -1 if they want to fold
if (pBet >= 0) // not folding
{
pot += pBet;
bet = playersIn[i].ChipsIn();
}
else // folding
{
if (playersIn[i].IsPlayer())
{
playerFolded = true;
}
playersIn.RemoveAt(i);
i--;
}
}
else
{
Console.WriteLine("They are all in, skipping go");
}
Thread.Sleep(1000);
}
if (playersIn.Count <= 1) // Checking if the round should be over
{
roundOver = true;
}
}
Console.WriteLine("COMMUNITY CARDS: ");
communityCards.DisplayHand();
foreach (Player p in playersIn) // Displaying players and their cards
{
Console.Write($"{p.GetName()}'s cards: ");
p.pHand.DisplayHand();
}
// Calculating winner
int highestHand = 0;
int highestScore = 0;
bool done = false;
for (int j = 0; j < 7;) // Do 7 times because 7 cards
{
for (int ii = 0; ii < 2; ii++) // Do twice
{
for (int i = 0; i < playersIn.Count; i++)
{
List <Tuple <int, int> > value = playersIn[i].GetHandValue();
if (value[j].Item1 > highestHand)
{
highestHand = value[j].Item1;
highestScore = value[j].Item2;
}
else if (value[j].Item1 == highestHand)
{
if (value[j].Item2 > highestScore)
{
highestScore = value[j].Item2;
}
else if (value[j].Item2 < highestScore)
{
playersIn.RemoveAt(i);
i--;
}
}
else if (value[j].Item1 < highestHand)
{
playersIn.RemoveAt(i);
i--;
highestScore = 0;
}
}
}
if (playersIn.Count > 1)
{
j++;
}
else
{
break;
}
}
int moneyToGive = pot / playersIn.Count;
foreach (Player p in playersIn)
{
Console.WriteLine($"{p.GetName()} wins {moneyToGive}!");
players[p.PLAYERID].AddChips(moneyToGive);
}
// ROUND IS OVER, CLEARING COMMUNITY CARDS
pack.AddCard(communityCards);
}
public void EvaluateHands()
{
//evaluate each players hand pre flop
HandEvaluator firstPlayerHandEvaluator = new HandEvaluator(FirstPlayerHand);
HandEvaluator firstComputerHandEvaluator = new HandEvaluator(FirstComputerHand);
//get each players high card value
Hand playerHighCard = firstPlayerHandEvaluator.EvaluateHand();
Hand computerHighCard = firstComputerHandEvaluator.EvaluateHand();
//create player's computer's evaluation objects (passing SORTED hand to constructor)
HandEvaluator playerHandEvaluator = new HandEvaluator(SortedPlayerHand);
HandEvaluator computerHandEvaluator = new HandEvaluator(SortedComputerHand);
//get the player's and computer's hand
Hand playerHand = playerHandEvaluator.EvaluateHand();
Hand computerHand = computerHandEvaluator.EvaluateHand();
//display each hand
Console.WriteLine("\n\n\n\n\n\n\n\nPlayer's Hand: " + playerHand);
Console.WriteLine("\nComputer's Hand: " + computerHand);
//evaluate hands
if (playerHand > computerHand)
{
Console.WriteLine("Player WINS!");
}
else if (playerHand < computerHand)
{
Console.WriteLine("Computer WINS!");
}
else
//if the hands are the same, evaluate the values
{
//first evaluate who has higher value of poker hand
if (playerHandEvaluator.HandValues.Total > computerHandEvaluator.HandValues.Total)
{
Console.WriteLine("Player WINS!");
}
else if (playerHandEvaluator.HandValues.Total < computerHandEvaluator.HandValues.Total)
{
Console.WriteLine("Computer WINS!");
}
//if both have the same poker hand (for example, both have a pair of queens),
//then the player with the next higher card wins
else if (firstPlayerHandEvaluator.HandValues.HighCard > firstComputerHandEvaluator.HandValues.HighCard)
{
Console.WriteLine("Player WINS!");
}
else if (firstPlayerHandEvaluator.HandValues.HighCard < firstComputerHandEvaluator.HandValues.HighCard)
{
Console.WriteLine("Computer WINS!");
}
//if high card is of same value check second card in players hand
else if (firstPlayerHandEvaluator.HandValues.SecondHighCard > firstComputerHandEvaluator.HandValues.SecondHighCard)
{
Console.WriteLine("Player WINS!");
}
else if (firstPlayerHandEvaluator.HandValues.SecondHighCard < firstComputerHandEvaluator.HandValues.SecondHighCard)
{
Console.WriteLine("Computer WINS!");
}
else
{
Console.WriteLine("DRAW, everyone's a winner!");
}
}
}
public TwoPair(Hand hand) : base(hand)
{
}
private Player[] determine_winners()
{
// guard conditions
if (player_queue.Count < 1)
{
return(new Player[0]);
}
Player[] winners = new Player[player_queue.Count];
int index = 0;
Hand_Values best_hand_value = (Hand_Values)0;
Card_Value best_card_value = (Card_Value)0;
// get best hand/card combo
foreach (Player player in player_queue)
{
if (player != null &&
player.hand != null &&
!player.folded &&
!player.is_out)
{
if (player.hand.best_hand_value > best_hand_value)
{
best_hand_value = player.hand.best_hand_value;
if (player.hand.cards[0] != null)
{
best_card_value = player.hand.cards[0].value;
}
else
{
Console.WriteLine("ERROR: Null card existing in hand when determining round winner.");
}
}
else if (player.hand.best_hand_value == best_hand_value)
{
if (player.hand.cards[0] != null &&
player.hand.cards[0].value > best_card_value)
{
best_card_value = player.hand.cards[0].value;
}
}
}
else if (player == null ||
player.hand == null)
{
Console.WriteLine("ERROR: Null player or hand possessed by player when determining round winner.");
}
}
foreach (Player player in player_queue)
{
if (player == null ||
player.hand == null ||
player.hand.cards[0] == null)
{
Console.WriteLine("ERROR: Null exception when determining round winner.");
}
else if (!player.folded &&
!player.is_out &&
player.hand.best_hand_value == best_hand_value &&
player.hand.cards[0].value == best_card_value)
{
winners[index++] = player;
}
}
// use tiebreaker to determine the best of the winners
Hand[] hands = new Hand[index];
for (int i = 0; i < index; i++)
{
hands[i] = winners[i].hand;
}
Card_Value tie_breaking_card = Hand.tie_breaker(hands);
// use tie breaking card to figure out who the winner of winners is
Player[] winners_of_winners = new Player[winners.Length];
Card_Value best_tie_card_value = Hand.get_best_tie_card(winners[0].hand).value;
// find the best tie card value
for (int i = 0; i < winners.Length; i++)
{
if (winners[i] == null)
{
break;
}
else
{
Card best_tie_card = Hand.get_best_tie_card(winners[i].hand);
if (best_tie_card.value > best_tie_card_value)
{
best_tie_card_value = best_tie_card.value;
}
}
}
// select the winners of the winners using the tie breaking card value
index = 0;
for (int i = 0; i < winners.Length; i++)
{
if (winners[i] == null)
{
break;
}
else if (Hand.get_best_tie_card(winners[i].hand).value == best_tie_card_value)
{
winners_of_winners[index++] = winners[i];
}
}
// condense
Player[] winners_no_nulls = new Player[index];
for (int i = 0; i < index; i++)
{
winners_no_nulls[i] = winners_of_winners[i];
}
return(winners_no_nulls);
}
