/// <summary>
/// Calculate the best possible rank for a hand and a deck
/// </summary>
/// <param name="hand"></param>
/// <param name="deck"></param>
/// <returns></returns>
public static HandRank GetBestRank(IReadOnlyList <Card> hand, IReadOnlyList <Card> deck)
{
if (hand.Count != Constants.CardsInOneHand)
{
throw new ArgumentException(string.Format("Hand should contain {0} cards", Constants.CardsInOneHand));
}
HandRank currentRank = HandRank.HighestCard;
// Brute force all possible hands (with this deck)
foreach (var handCopy in GetAllPossibleHands(hand, deck))
{
// Calculate best rank for this hand
var rankForCurrentHand = GetBestRank(handCopy);
// No need to search further if you found a straight flush
if (rankForCurrentHand == HandRank.StraightFlush)
{
return(HandRank.StraightFlush);
}
// Found a beter rank?
if (rankForCurrentHand < currentRank)
{
currentRank = rankForCurrentHand;
}
}
return(currentRank);
}
/// <summary>
/// This method is used if both players have the same handrank.
/// In Texas Hold'em only the best five cards are measured to determine the winner.
/// </summary>
/// <returns></returns>
public List <Card> GetTopFiveCards(HandRank rank)
{
switch (rank)
{
case HandRank.RoyalFlush:
return(getRoyalFlushCards());
case HandRank.StraightFlush:
return(getStraightFlushCards());
case HandRank.FourOfAKind:
return(getTopFiveCardsOfSameValue(4));
case HandRank.FullHouse:
return(getFullHouseCards());
case HandRank.Flush:
return(getFlushCards());
case HandRank.Straight:
return(getStraightCards());
case HandRank.ThreeOfAKind:
return(getTopFiveCardsOfSameValue(3));
case HandRank.TwoPairs:
return(getTwoPairCards());
case HandRank.Pair:
return(getTopFiveCardsOfSameValue(2));
default:
return(cardsOrderedByValue.Take(5).ToList());
}
}
public static bool UsesKicker( HandRank rank )
{
if ( rank < HandRank.Straight || rank == HandRank.FourOfAKind )
return true;
return false;
}
public HandEvaluation(HandRank rank, CardRank highcard, CardRank lowcard, params CardRank[] kickers)
{
Rank = rank;
HighCard = highcard;
LowCard = lowcard;
Kickers = kickers;
}
public static List <PokerPlayer> DetermineWinner(List <PokerPlayer> activePlayers)
{
List <PokerPlayer> winners = new List <PokerPlayer>();
winners.Add(activePlayers[0]);
HandRank bestHand = activePlayers[0].GetHandRank();
for (int i = 1; i < activePlayers.Count; ++i)
{
HandRank hand = activePlayers[i].GetHandRank();
int result = hand.CompareTo(bestHand);
if (result == 1)
{
bestHand = hand;
winners.Clear();
winners.Add(activePlayers[i]);
}
else if (result == 0)
{
winners.Add(activePlayers[i]);
}
}
return(winners);
}
public static string RankString(HandRank rank)
{
switch (rank)
{
case HandRank.None:
return "high card";
case HandRank.OnePair:
return "one pair";
case HandRank.TwoPairs:
return "two pairs";
case HandRank.ThreeOfAKind:
return "three of a kind";
case HandRank.Straight:
return "a straight";
case HandRank.Flush:
return "a flush";
case HandRank.FullHouse:
return "a full house";
case HandRank.FourOfAKind:
return "four of a kind";
case HandRank.StraightFlush:
return "a straight flush";
case HandRank.RoyalFlush:
return "a royal flush";
}
return String.Empty;
}
// Returns true if Player1 won Game using draw poker rules
static bool Player1Won(string Game)
{
string[] Hand1 = Game.Substring(0, 14).Split(' ');
string[] Hand2 = Game.Substring(15).Split(' ');
int[] Hand1CardCounters = GetCardCounters(Hand1);
int[] Hand2CardCounters = GetCardCounters(Hand2);
HandRank Hand1Rank = GetHandRank(Hand1, Hand1CardCounters);
HandRank Hand2Rank = GetHandRank(Hand2, Hand2CardCounters);
if (Hand1Rank != Hand2Rank)
{
return(Hand1Rank > Hand2Rank);
}
int RankCard1 = GetRankCard(Hand1Rank, Hand1CardCounters);
int RankCard2 = GetRankCard(Hand2Rank, Hand2CardCounters);
if (RankCard1 != RankCard2)
{
return(RankCard1 > RankCard2);
}
for (int i = CardValues.Length - 1; i >= 0; i--)
{
int CardCounter1 = Hand1CardCounters[i];
int CardCounter2 = Hand2CardCounters[i];
if (CardCounter1 != CardCounter2)
{
return(CardCounter1 > CardCounter2);
}
}
throw new Exception("No winner found for " + Game);
}
public void HandRank_CompareTo_RankIsGreater()
{
var test = new HandRank(HandRankEnum.RoyalFlush);
var test2 = new HandRank(HandRankEnum.StraighFlush);
Assert.AreEqual(1, test.CompareTo(test2));
Assert.AreEqual(-1, test2.CompareTo(test));
}
//----==== PRIVATE ====--------------------------------------------------------------------
private void HighCardValues(IHand hand, HandRank rank)
{
var cardValues = (from card in hand.Cards
orderby card.HighValue
select card.HighValue).Distinct().ToList();
rank.SetHighCardValues(cardValues);
}
public void DetermineHandRank(Card[] cards)
{
FixAceTo14(cards);
Array.Sort(cards, (x, y) => y._value.CompareTo(x._value)); //decending
if (IsRoyalFlush(cards))
{
_rank = HandRank.ROYAL_FLUSH;
}
else if (IsAStraightFlush(cards))
{
_rank = HandRank.STRAIGHT_FLUSH;
}
else if (IsAFourOfAKind(cards))
{
_rank = HandRank.FOUR_OF_A_KIND;
}
else if (IsAFullHouse(cards))
{
_rank = HandRank.FULL_HOUSE;
}
else if (IsAFlush(cards) != Suits.None)
{
_rank = HandRank.FLUSH;
}
else if (IsAStraight(cards) != Suits.None)
{
_rank = HandRank.STRAIGHT;
}
else if (IsThreeOfAKind(cards))
{
_rank = HandRank.THREE_OF_A_KIND;
}
else if (IsTwoPair(cards))
{
_rank = HandRank.TWO_PAIR;
}
else if (IsPair(cards))
{
_rank = HandRank.PAIR;
}
else
{
_rank = HandRank.HIGH_CARD;
_relevantCards.Clear();
FixAceTo14(cards);
Array.Sort(cards, (x, y) => y._value.CompareTo(x._value)); //decending
int i = 0;
while (i < cards.Count() && _relevantCards.Count < 5)
{
if (!_relevantCards.Contains(cards[i]))
{
_relevantCards.Add(cards[i]);
}
i++;
}
}
FixAceTo1(cards);
}
public IHandComparer GetComparer(HandRank rank)
{
if (_comparerMap.ContainsKey(rank))
{
return(Activator.CreateInstance(_comparerMap[rank]) as IHandComparer);
}
throw new Exception($"Could not find a valid comparer for rank {rank}");
}
public PokerHand(List <Card> cards)
{
if (cards.Count != _maxCards)
{
throw new ArgumentException("Too many Cards! 5 only for this game!");
}
Cards = cards;
_rank = HandRank.HighCard;
}
public void handranker_testhands_ranking(string communityCards, string playerCards, HandTypes ranking)
{
Hand hand = new Hand(communityCards, playerCards);
HandRank handRanker = new HandRank();
handRanker.Run(hand);
Assert.That(handRanker.Ranking, Is.EqualTo(ranking));
}
public static bool UsesKicker(HandRank rank)
{
if (rank < HandRank.Straight || rank == HandRank.FourOfAKind)
{
return(true);
}
return(false);
}
public void Reset()
{
rank = HandRank.HighCard;
primaryRank = Card.Rank.Unknown;
secondRank = Card.Rank.Unknown;
kicker1Rank = Card.Rank.Unknown;
kicker2Rank = Card.Rank.Unknown;
kicker3Rank = Card.Rank.Unknown;
}
public HandStrength(HandStrength copy)
{
rank = copy.rank;
primaryRank = copy.primaryRank;
secondRank = copy.secondRank;
kicker1Rank = copy.kicker1Rank;
kicker2Rank = copy.kicker2Rank;
kicker3Rank = copy.kicker3Rank;
}
public override int CompareToOffsuitHand(OffsuitHandBase other)
{
var otherStraight = other as Straight;
if (otherStraight == null)
{
return(HandRank.CompareTo(other.HandRank));
}
return(TopCardRank.CompareTo(otherStraight.TopCardRank));
}
/**
* Register rules that is pre-defined
*
* @param {HandRank} ruleName name of the rule
*/
public static void RegisterRules(HandRank ruleName)
{
if (!ALLRULES.Contains(ruleName))
{
throw new InvalidPokerRuleException(ruleName.ToString());
}
else if (!rules.Contains(ruleName))
{
rules.Add(ruleName);
}
}
//Function to show hand
public void ShowHand()
{
//verify of Royal Flush
if (RoyalFlush())
{
this.handType = HandRank.RoyalFlush;
Console.WriteLine("Wow you got a lucky hand. You got a ROYAL FLUSH\nYour Score is: " + (int)this.handType);
}
else if (StraightFlush())
{
this.handType = HandRank.StraightFlush;
Console.WriteLine("Wow you got a good hand. You got a STRAIGHT FLUSH\nYour Score is: " + (int)this.handType);
}
else if (FourOfAKind())
{
this.handType = HandRank.FourOfAKind;
Console.WriteLine("You got FOUR OF A KIND\nYour Score is: " + (int)this.handType);
}
else if (FullHouse())
{
this.handType = HandRank.FullHouse;
Console.WriteLine("You got FOUR OF A KIND\nYour Score is: " + (int)this.handType);
}
else if (Flush())
{
this.handType = HandRank.Flush;
Console.WriteLine("You got FLUSH\nYour Score is: " + (int)this.handType);
}
else if (Straight())
{
this.handType = HandRank.Straight;
Console.WriteLine("You got STRAIGHT\nYour Score is: " + (int)this.handType);
}
else if (ThreeOfAKind())
{
this.handType = HandRank.ThreeOfAKind;
Console.WriteLine("You got THREE OF A KIND\nYour Score is: " + (int)this.handType);
}
else if (TwoPairs())
{
this.handType = HandRank.TwoPairs;
Console.WriteLine("You got TWO PAIRS\nYour Score is: " + (int)this.handType);
}
else if (OnePair())
{
this.handType = HandRank.OnePair;
Console.WriteLine("You got ONE PAIR\nYour Score is: " + (int)this.handType);
}
else //Show players High Card
{
this.handType = HandRank.HighCard;
Console.WriteLine("Better luck next time your HIGH CARD and also your Score is: " + (int)this.cards.Max(x => x.Rank));
}
}
public override int CompareToOffsuitHand(OffsuitHandBase other)
{
var otherFourSome = other as FourSome;
if (otherFourSome == null)
{
return(HandRank.CompareTo(other.HandRank));
}
return(Kicker.CompareTo(otherFourSome.Kicker));
}
public override int CompareToSuitedHand(SuitedHandBase other)
{
var otherStraightFlush = other as StraightFlush;
if (otherStraightFlush == null)
{
return(HandRank.CompareTo(other.HandRank));
}
return(TopRank.CompareTo(otherStraightFlush.TopRank));
}
private void TwoGroupRank(IHand hand, HandRank rank)
{
var group = (from card in hand.Cards
group card by card.Name into grouped
orderby grouped.Count() descending
select grouped);
// Should only be two groups.
rank.RankHighCardValue = group.First().First().HighValue;
rank.RankSecondHighCardValue = group.Last().First().HighValue;
}
public Player(string s)
{
card.Add(new Card(s[0].ToString(), s[1].ToString()));
card.Add(new Card(s[3].ToString(), s[4].ToString()));
card.Add(new Card(s[6].ToString(), s[7].ToString()));
card.Add(new Card(s[9].ToString(), s[10].ToString()));
card.Add(new Card(s[12].ToString(), s[13].ToString()));
card = card.OrderBy(x => x.value).ToList();
rank = getRank();
setValueCardsToCompare();
}
void Start()
{
this.CurrentMoneyText.text = "Money: " + StaticVar.Money;
this.CurrentBetText.text = "Bet: " + this.Bet.ToString();
this.StartButton.onClick.AddListener(() => StartGame());
this.AutoplayButton.onClick.AddListener(() => AutoplayClicked());
this.Bet50Button.onClick.AddListener(() => BetButtonPressed());
this.Bet100Button.onClick.AddListener(() => BetButtonPressed());
this.Bet500Button.onClick.AddListener(() => BetButtonPressed());
this.RestBetButton.onClick.AddListener(() => ResetBetPressed());
Rank = new HandRank();
}
static void Main(string[] args)
{
string playersHand = Console.ReadLine();
string[] cards = playersHand.Replace(",", "").Split(' ');
if (cards.Count() != 5 || !isValidHand(cards))
{
Console.WriteLine("invalid input");
return;
}
fillStraightValues();
HandRank rankOutput = calculateRank(cards);
switch (rankOutput)
{
case HandRank.StraightFlush:
Console.WriteLine("straight flush");
break;
case HandRank.FourOfAKind:
Console.WriteLine("four of a kind");
break;
case HandRank.FullHouse:
Console.WriteLine("full house");
break;
case HandRank.Flush:
Console.WriteLine("flush");
break;
case HandRank.Straight:
Console.WriteLine("straight");
break;
case HandRank.ThreeOfKind:
Console.WriteLine("three of a kind");
break;
case HandRank.TwoPair:
Console.WriteLine("two pair");
break;
case HandRank.OnePair:
Console.WriteLine("one pair");
break;
case HandRank.HighCard:
Console.WriteLine("high card");
break;
}
}
public void TestStraightFlush()
{
Hand hand = new Hand();
hand.Draw(new Card(CardSuit.Club, CardValue.Four));
hand.Draw(new Card(CardSuit.Club, CardValue.Three));
hand.Draw(new Card(CardSuit.Club, CardValue.Six));
hand.Draw(new Card(CardSuit.Club, CardValue.Five));
hand.Draw(new Card(CardSuit.Club, CardValue.Seven));
HandRank expected = HandRank.StraightFlush;
HandRank actual = hand.GetHandRank();
Assert.AreEqual(expected, actual, "StraightFlush not detected");
}
public void HandRank_CompareTo_RankHighCardIsGreater()
{
var test = new HandRank(HandRankEnum.StraighFlush)
{
RankHighCardValue = 8
};
var test2 = new HandRank(HandRankEnum.StraighFlush)
{
RankHighCardValue = 7
};
Assert.AreEqual(1, test.CompareTo(test2));
Assert.AreEqual(-1, test2.CompareTo(test));
}
public void TestFlush()
{
Hand hand = new Hand();
hand.Draw(new Card(CardSuit.Diamond, CardValue.Ace));
hand.Draw(new Card(CardSuit.Diamond, CardValue.Four));
hand.Draw(new Card(CardSuit.Diamond, CardValue.Seven));
hand.Draw(new Card(CardSuit.Diamond, CardValue.Two));
hand.Draw(new Card(CardSuit.Diamond, CardValue.Eight));
HandRank expected = HandRank.Flush;
HandRank actual = hand.GetHandRank();
Assert.AreEqual(expected, actual, "Flush not detected");
}
public void HandRank_CompareTo_HighCardIsGreater()
{
var test = new HandRank(HandRankEnum.Flush)
{
RankHighCardValue = 8, RankSecondHighCardValue = 7, HighCardValue = 5
};
var test2 = new HandRank(HandRankEnum.Flush)
{
RankHighCardValue = 8, RankSecondHighCardValue = 7, HighCardValue = 3
};
Assert.AreEqual(1, test.CompareTo(test2));
Assert.AreEqual(-1, test2.CompareTo(test));
}
public void TestFullHouse()
{
Hand hand = new Hand();
hand.Draw(new Card(CardSuit.Diamond, CardValue.Seven));
hand.Draw(new Card(CardSuit.Heart, CardValue.Queen));
hand.Draw(new Card(CardSuit.Club, CardValue.Queen));
hand.Draw(new Card(CardSuit.Spade, CardValue.Seven));
hand.Draw(new Card(CardSuit.Spade, CardValue.Queen));
HandRank expected = HandRank.FullHouse;
HandRank actual = hand.GetHandRank();
Assert.AreEqual(expected, actual, "FullHouse not detected");
}
public HandRankEvaluator(PokerPlayer player)
{
Player = player;
SortedHand = HandSortedByRank(player.Hand);
CurrentHandRank = CalculateRank(SortedHand);
//if HIGH_CARD get value
if (CurrentHandRank == HandRank.HIGH_CARD)
{
HighCardValue = SortedHand[4].Value;
CardsNotInPlay = SortedHand.Where(c => c.Value != HighCardValue)
.OrderBy(c => c.Value).ToList();
}
}
private void SetRankings()
{
List <HandRank> rankings = new List <HandRank>();
foreach (Hand hand in _hands)
{
HandRank handRank = new HandRank();
handRank.Run(hand);
rankings.Add(handRank);
}
_rankings = rankings.OrderByDescending(r => r.Ranking)
.ThenByDescending(r => r.HighCard)
.ToList();
}
public void TestHandRanking(string input, HandRank expected)
{
var hand = new Hand(input);
Assert.AreEqual(expected, hand.Rank);
}
