private PokerHands GetHandRank()
{
PokerHands result = PokerHands.HighCard; //min value is the default
value = GetHighCardValue();
if (IsFourOfAKind())
{
result = PokerHands.FourOfAKind;
}
else if (IsFullHouse())
{
result = PokerHands.FullHouse;
}
else if (IsFlush())
{
result = PokerHands.Flush;
}
else if (IsThreeOfAKind())
{
result = PokerHands.ThreeOfAKind;
}
return(result);
}
public void with_full_house_get_15_points()
{
List <CardInfo> cardInfos = new List <CardInfo>();
for (int i = 0; i < 5; i++)
{
GameObject card = new GameObject("Card" + i);
CardInfo cardInfo = card.AddComponent <CardInfo>();
if (i < 3)
{
cardInfo.CardValue = Value.Ace;
cardInfo.CardSuit = Suit.Diamond;
}
else
{
cardInfo.CardValue = Value.King;
cardInfo.CardSuit = Suit.Spade;
}
cardInfos.Add(cardInfo);
}
PokerHands pokerHand = new PokerHands();
int result = (int)pokerHand.EvaluatePokerHand(cardInfos);
Assert.AreEqual(15, result);
}
public void with_two_pairs_get_3_points()
{
List <CardInfo> cardInfos = new List <CardInfo>();
for (int i = 0; i < 5; i++)
{
GameObject card = new GameObject("Card" + i);
CardInfo cardInfo = card.AddComponent <CardInfo>();
if (i < 2)
{
cardInfo.CardValue = Value.Eight;
cardInfo.CardSuit = Suit.Club + i;
}
else if (i < 4)
{
cardInfo.CardValue = Value.Two;
cardInfo.CardSuit = Suit.Heart;
}
else
{
cardInfo.CardValue = Value.Ace;
cardInfo.CardSuit = Suit.Spade;
}
cardInfos.Add(cardInfo);
}
PokerHands pokerHand = new PokerHands();
int result = (int)pokerHand.EvaluatePokerHand(cardInfos);
Assert.AreEqual(3, result);
}
public int GetPokerHandsWinner(PokerHands pokerHands)
{
var result = -1;
if (pokerHands == null || pokerHands?.Hands == null || pokerHands?.Hands.Length == 0 || pokerHands?.Hands.Length % cardPerhand != 0) // always validate input at the entrance of a public method
{
return(result);
}
try
{
var player1HandValue = _rank.GetRankValue(GetHandCards(pokerHands.Hands.Take(cardPerhand)));
var player2HandValue = _rank.GetRankValue(GetHandCards(pokerHands.Hands.Skip(5).Take(cardPerhand)));
if (player1HandValue > player2HandValue)
{
return(1);
}
return(0);
}
catch (Exception)
{
// shout out// throw;
}
return(0);
}
public void with_poker_get_20_points()
{
List <CardInfo> cardInfos = new List <CardInfo>();
for (int i = 0; i < 5; i++)
{
GameObject card = new GameObject("Card" + i);
CardInfo cardInfo = card.AddComponent <CardInfo>();
if (i < 4)
{
cardInfo.CardValue = Value.Four;
cardInfo.CardSuit = Suit.Club + i;
}
else
{
cardInfo.CardValue = Value.Seven;
cardInfo.CardSuit = Suit.Spade;
}
cardInfos.Add(cardInfo);
}
PokerHands pokerHand = new PokerHands();
int result = (int)pokerHand.EvaluatePokerHand(cardInfos);
Assert.AreEqual(20, result);
}
public void with_three_of_a_kind_get_5_points()
{
List <CardInfo> cardInfos = new List <CardInfo>();
for (int i = 0; i < 5; i++)
{
GameObject card = new GameObject("Card" + i);
CardInfo cardInfo = card.AddComponent <CardInfo>();
if (i < 3)
{
cardInfo.CardValue = Value.Jack;
cardInfo.CardSuit = Suit.Club + i;
}
else
{
cardInfo.CardValue = Value.Two + i;
cardInfo.CardSuit = Suit.Spade;
}
cardInfos.Add(cardInfo);
}
PokerHands pokerHand = new PokerHands();
int result = (int)pokerHand.EvaluatePokerHand(cardInfos);
Assert.AreEqual(5, result);
}
private List <PokerPlayer> TieBreaker(List <PokerPlayer> players, PokerHands highestHand)
{
Dictionary <Hand, PokerPlayer> reverseDic = new Dictionary <Hand, PokerPlayer>();
var winnerList = new List <PokerPlayer>();
foreach (var p in players)
{
reverseDic.Add(rankings[p], p);
}
var tieList = reverseDic.Keys.ToList();
if (highestHand == PokerHands.TWOPAIR || highestHand == PokerHands.FULLHOUSE)
{
tieList.Sort(new HandComparerMultiPairDesc());
}
else
{
tieList.Sort(new HandComparerDesc());
}
var winners = GetWinnersIfEqual(tieList);
foreach (var w in winners)
{
winnerList.Add(reverseDic[w]);
}
return(winnerList);
}
public void Example()
{
int expected = 6 * 9;
int actual = new PokerHands().Answer;
Assert.AreEqual(expected, actual);
}
public void SampleTests(string[] black, string[] white, string expected)
{
var Kata = new PokerHands();
var actual = Kata.WhoWin(black, white);
Assert.AreEqual(expected, actual);
}
public IEnumerable <IGrouping <int, Card> > GetMatchingCards(PokerHands type)
{
IEnumerable <IGrouping <int, Card> > matchingCards = this
.GroupBy(c => c.Value)
.Where(g => g.Count() == (int)type);
return(matchingCards);
}
public void TestThreeofaKind()
{
PlayerCards = "2H 3D 5S AH 9C 9S KH 7D 7C 7S";
var actual = PokerHands.CalculateWinner(PlayerCards);
var expected = PokerConstants.RightHandWins;
Assert.AreEqual(expected, actual);
}
public void TestPair()
{
PlayerCards = "4H 8S 9C KD KH 2C 3H 4D 8C TD";
var actual = PokerHands.CalculateWinner(PlayerCards);
var expected = PokerConstants.LeftHandWins;
Assert.AreEqual(expected, actual);
}
public void TestTwoPair()
{
PlayerCards = "2H 4S 4C 2D KH 2C 3H 4S 8C KD";
var actual = PokerHands.CalculateWinner(PlayerCards);
var expected = PokerConstants.LeftHandWins;
Assert.AreEqual(expected, actual);
}
public void TestHighCard()
{
PlayerCards = "2C 3H 4S 8C 9D 2H 3D 5S 9C AH";
var actual = PokerHands.CalculateWinner(PlayerCards);
var expected = PokerConstants.RightHandWins;
Assert.AreEqual(expected, actual);
}
public void TestRoyalFlush()
{
PlayerCards = "2S 3S 4S 6S 5S KS JS AS QS TS";
var actual = PokerHands.CalculateWinner(PlayerCards);
var expected = PokerConstants.RightHandWins;
Assert.AreEqual(expected, actual);
}
public void TestDraw()
{
PlayerCards = "2H 3D 5S 9C KD 2D 3H 5C 9S KH";
var actual = PokerHands.CalculateWinner(PlayerCards);
var expected = PokerConstants.Draw;
Assert.AreEqual(expected, actual);
}
public void TestFourofaKind()
{
PlayerCards = "7H 7D 7C 7S KD 2D 3H 5C 9S 2H";
var actual = PokerHands.CalculateWinner(PlayerCards);
var expected = PokerConstants.LeftHandWins;
Assert.AreEqual(expected, actual);
}
public void TestStraightFlush()
{
PlayerCards = "7H 7D 7C 7S KD 2S 3S 4S 6S 5S";
var actual = PokerHands.CalculateWinner(PlayerCards);
var expected = PokerConstants.RightHandWins;
Assert.AreEqual(expected, actual);
}
public void TestStraight()
{
PlayerCards = "2H 3D 5S AH 9C 2C 3S 4D 6H 5C";
var actual = PokerHands.CalculateWinner(PlayerCards);
var expected = PokerConstants.RightHandWins;
Assert.AreEqual(expected, actual);
}
public void TestFlush()
{
PlayerCards = "2H 3D 4C 6H 5S 2S 8S AS QS 3S";
var actual = PokerHands.CalculateWinner(PlayerCards);
var expected = PokerConstants.RightHandWins;
Assert.AreEqual(expected, actual);
}
public void Test(IEnumerable <Card> cards, PokerHands expected)
{
var detector = new PokerHandsDetector();
var pokerHands = detector.Detect(cards);
Assert.AreEqual(expected, pokerHands);
}
public void FullHouse()
{
PlayerCards = "2S 4S 4C 2D 4H 2H 3D 5S AH 9C";
var actual = PokerHands.CalculateWinner(PlayerCards);
var expected = PokerConstants.LeftHandWins;
Assert.AreEqual(expected, actual);
}
public static PokerHands CheckHand(ref List <Card> Hand, List <Card> cards)
{
PokerHands handresult = PokerHands.NONE;
SortCards(ref cards);
Hand.Clear();
if (CheckFlush(ref Hand, cards))
{
if (CheckRoyal(Hand))
{
return(PokerHands.ROYAL_FLUSH);
}
if (CheckStraight(Hand))
{
return(PokerHands.STRAIGHT_FLUSH);
}
//isFlush = true;
return(PokerHands.FLUSH);
}
if (CheckFourOfAKind(ref Hand, cards))
{
return(PokerHands.FOUR_OF_A_KIND);
}
if (CheckFullHouse(ref Hand, cards))
{
return(PokerHands.FULL_HOUSE);
}
if (CheckStraight(ref Hand, cards))
{
return(PokerHands.STRAIGHT);
}
if (CheckThreeOfAKind(ref Hand, cards))
{
return(PokerHands.THREE_PAIR);
}
handresult = CheckTwoPair(ref Hand, cards);
if (handresult == PokerHands.HIGH_CARD)
{
Hand.Clear();
for (int g = cards.Count - 1; g > 1; g--)
{
Hand.Add(cards[g]);
}
}
return(handresult);
}
public void StartGame()
{
PokerHands pokerHands = new PokerHands();
PokerHand pokerHand = pokerHands.EvaluatePokerHand(PlayerCards);
gameScore.UpdateScore((int)pokerHand);
gameScore.UpdateHand(pokerHand.ToString());
scoreChanged.Raise();
}
/// <summary>
/// Checks if the input entered is a valid input.
/// </summary>
/// <param name="pokerHandsData"></param>
/// <returns>Analyse the game if true else throw error</returns>
public static string EvaluatePokerHands(string pokerHandsData)
{
if (!CheckForPokerCardHandsDataIsValid(pokerHandsData))
{
throw new Exception(PokerConstants.InvalidInputMessage);
}
else
{
return(PokerHands.PlayerCards(pokerHandsData));
}
}
/// <summary>
/// Converts the given Hands with absolute ratios into Hands with relative ratios
/// This is done by replaying the hand and determining the relation of each action ratio
/// to the pot or the amount that needed to be called
/// </summary>
/// <param name="sortedAquiredHands">Hands to be converted</param>
/// <returns>Converted Hands</returns>
public IPokerHands ConvertAquiredHands(IPokerHands sortedAquiredHands)
{
var convertedHands = new PokerHands();
for (int i = 0; i < sortedAquiredHands.Hands.Count; i++)
{
IConvertedPokerHand convertedHand = ConvertAquiredHand((IAquiredPokerHand)sortedAquiredHands.Hands[i]);
// Only add hands with active players
if (convertedHand != null)
{
convertedHands.AddHand(convertedHand);
}
}
return(convertedHands);
}
private static void PrintHand(List <Card> playerCards, List <Card> tableCards)
{
switch (PokerHands.CheckHand(playerCards, tableCards))
{
case Hand.RoyalFlush:
Console.WriteLine("Yheeee You have a Royal Flush!!!");
break;
case Hand.StraightFlush:
Console.WriteLine("Yheeee You have a Straight Flush!!!");
break;
case Hand.FourOfaKind:
Console.WriteLine("Yheeee You have Four Of a Kind!!!");
break;
case Hand.FullHouse:
Console.WriteLine("Yheeee You have a Full House!!!");
break;
case Hand.Flush:
Console.WriteLine("Yheeee You have a Flush!!!");
break;
case Hand.Straight:
Console.WriteLine("Yheeee You have a Straight!!!");
break;
case Hand.ThreeOfaKind:
Console.WriteLine("Yheeee You have Three Of a Kind!!!");
break;
case Hand.TwoPair:
Console.WriteLine("Yheeee You have TWO PAIR!!!");
break;
case Hand.Pair:
Console.WriteLine("Yheeee You have a PAIR!!!");
break;
case Hand.HightCard:
Console.WriteLine("You have only hight card :(");
break;
}
}
public void with_royal_flush_get_100_points()
{
List <CardInfo> cardInfos = new List <CardInfo>();
for (int i = 0; i < 5; i++)
{
GameObject card = new GameObject("Card" + i);
CardInfo cardInfo = card.AddComponent <CardInfo>();
cardInfo.CardValue = Value.Ten + i;
cardInfo.CardSuit = Suit.Diamond;
cardInfos.Add(cardInfo);
}
PokerHands pokerHand = new PokerHands();
int result = (int)pokerHand.EvaluatePokerHand(cardInfos);
Assert.AreEqual(100, result);
}
public void ShowHand()
{
if (RoyalFlush())
{
PokerHands = (PokerHands)9;
}
else if (StraightFlush())
{
PokerHands = (PokerHands)8;
}
else if (FourOfAKind())
{
PokerHands = (PokerHands)7;
}
else if (FullHouse())
{
PokerHands = (PokerHands)6;
}
else if (HasFlush())
{
PokerHands = (PokerHands)5;
}
else if (Straight())
{
PokerHands = (PokerHands)4;
}
else if (ThreeOfAKind())
{
PokerHands = (PokerHands)3;
}
else if (TwoPair())
{
PokerHands = (PokerHands)2;
}
else if (HasOnePair())
{
PokerHands = (PokerHands)1;
}
Console.WriteLine(PokerHands);
}
public void with_straight_get_10_points()
{
List <CardInfo> cardInfos = new List <CardInfo>();
for (int i = 0; i < 5; i++)
{
int sum = i > 3 ? 0 : i;
GameObject card = new GameObject("Card" + i);
CardInfo cardInfo = card.AddComponent <CardInfo>();
cardInfo.CardValue = Value.Two + i;
cardInfo.CardSuit = Suit.Club + sum;
cardInfos.Add(cardInfo);
}
PokerHands pokerHand = new PokerHands();
int result = (int)pokerHand.EvaluatePokerHand(cardInfos);
Assert.AreEqual(10, result);
}
public override void StartRound(StartRoundContext context)
{
this.currentPot = context.CurrentPot;
//TODO: inspect current pot
List<PlayingCard> playingCards = new List<PlayingCard>();
if (context.CommunityCards.Count > 2)
{
foreach (var card in context.CommunityCards)
{
playingCards.Add(new PlayingCard(card.Suit, card.Type));
}
playingCards.Add(new PlayingCard(this.firstCard.Suit, this.firstCard.Type));
playingCards.Add(new PlayingCard(this.secondCard.Suit, this.secondCard.Type));
this.ourCompleteHand = EvaluateHandRaiseTwo(playingCards);
playingCards.Clear();
}
}
public override void EndRound(EndRoundContext context)
{
this.ourCompleteHand = PokerHands.Nothing;
}
public GamerPokerHand(PokerGamer gamer, PokerHands pokerHand)
{
Gamer = gamer;
PokerHand = pokerHand;
}
