public static void GetWinnerByHighestCard(Game game)
{
int p1HandValue = 0;
int p2HandValue = 0;
List <Card> p1Cards = game.Player1.HandPlayed.Cards;
List <Card> p2Cards = game.Player2.HandPlayed.Cards;
p1HandValue = CardUtilities.GetTotalHandValue(p1Cards);
p2HandValue = CardUtilities.GetTotalHandValue(p2Cards);
if (p1HandValue > p2HandValue)
{
game.Player1.IsWinner = true;
}
else if (p2HandValue > p1HandValue)
{
game.Player2.IsWinner = true;
}
else
{
Player winner = FindPlayerWithHighestCard(game.Player1, game.Player2);
if (winner == game.Player1)
{
game.Player1.IsWinner = true;
}
else
{
game.Player2.IsWinner = true;
}
}
}
public void EvaluateGame(Game game)
{
// get type of hand and cards to play
game.Player1.HandPlayed = GetHandToPlay(game.Player1.HandDealt.Cards);
game.Player2.HandPlayed = GetHandToPlay(game.Player2.HandDealt.Cards);
// check if both players have the same type of hand, and if so calculate the tie
if (game.Player2.HandPlayed.Type == game.Player1.HandPlayed.Type)
{
CardUtilities.CalculateTie(game);
}
else
{
// get the type of hands from the dictionary key and compare enum values to determine winner
var p1Hand = game.Player1.HandPlayed;
var p2Hand = game.Player2.HandPlayed;
if (p1Hand.Type > p2Hand.Type)
{
game.Player1.IsWinner = true;
}
else
{
game.Player2.IsWinner = true;
}
}
}
private bool IsStraight(List <Card> cards, out List <Card> returnCards)
{
bool result = false;
// get sequence of 5 consecutive cards if it exists
returnCards = CardUtilities.GetConsecutiveValues(cards);
if (returnCards.Count == 5)
{
result = true;
}
return(result);
}
private bool IsStraightFlush(List <Card> cards, out List <Card> returnCards)
{
bool result = false;
// get sequence of 5 consecutive cards if it exists
returnCards = CardUtilities.GetConsecutiveValues(cards);
if (returnCards.Count == 5)
{
var suits = returnCards.Select(x => x.Suit).Distinct().ToArray();
if (suits.Length == 1)
{
result = true;
}
}
return(result);
}
private void SortHand(string hand)
{
string[] cardArray = hand.Trim().Split(' ');
List <Card> cards = new List <Card>();
// add cards to hand
for (int i = 0; i < cardArray.Length; i++)
{
Char[] cardValue = cardArray[i].ToCharArray();
string value = cardValue[0].ToString();
string suit = cardValue[1].ToString();
Card card = new Card(value, suit);
cards.Add(card);
}
// sort hand numercially
this.m_sortedHand = cards.OrderBy(x => CardUtilities.ParseCardNumber(x.Number)).ToList();
}
public static List <Card> GetConsecutiveValues(List <Card> input)
{
var cards = new List <Card>();
var seq = new List <Card>();
foreach (var i in input)
{
int index = input.IndexOf(i);
int nextNumber = index < 4 ? CardUtilities.ParseCardNumber(input[index + 1].Number) : -1;
if (CardUtilities.ParseCardNumber(i.Number) + 1 == nextNumber)
{
cards.Add(i);
if (cards.Count == 4)
{
cards.Add(input[index + 1]);
break;
}
}
}
return(cards);
}
public static Player FindPlayerWithHighestCard(Player player1, Player player2)
{
Card p1HighestCard = GetHighCard(player1);
Card p2HighestCard = GetHighCard(player2);
if (CardUtilities.ParseCardNumber(p1HighestCard.Number) > CardUtilities.ParseCardNumber(p2HighestCard.Number))
{
return(player1);
}
else if (CardUtilities.ParseCardNumber(p2HighestCard.Number) > CardUtilities.ParseCardNumber(p1HighestCard.Number))
{
return(player2);
}
else
{
// if card numbers are equal add that card to the cards to play
player1.HandPlayed.Cards.Add(p1HighestCard);
player2.HandPlayed.Cards.Add(p2HighestCard);
// execute recursive method until highest card is reached
Player winner = FindPlayerWithHighestCard(player1, player2);
return(winner);
}
}
public HandToPlay GetHandToPlay(List <Card> cards)
{
HandToPlay result = null;
var returnCards = new List <Card>();
if (IsRoyalFlush(cards, out returnCards))
{
// royal flush
result = new HandToPlay(TypeOfHand.RoyalFlush, returnCards);
}
else if (IsStraightFlush(cards, out returnCards))
{
// straight flush
result = new HandToPlay(TypeOfHand.StraightFlush, returnCards);
}
else if (IsFourOfAKind(cards, out returnCards))
{
// four of a kind
result = new HandToPlay(TypeOfHand.FourOfAKind, returnCards);
}
else if (IsFlush(cards, out returnCards))
{
// flush
result = new HandToPlay(TypeOfHand.Flush, returnCards);
}
else if (IsStraight(cards, out returnCards))
{
// straight
result = new HandToPlay(TypeOfHand.Straight, returnCards);
}
else if (IsThreeOfAKind(cards, out returnCards))
{
var unplayedCards = CardUtilities.GetUnplayedCards(cards, returnCards);
if (IsOnePair(unplayedCards, out returnCards))
{
// full house
result = new HandToPlay(TypeOfHand.FullHouse, returnCards);
}
else
{
// three of a kind
result = new HandToPlay(TypeOfHand.ThreeOfAKind, returnCards);
}
}
else if (IsTwoPairs(cards, out returnCards))
{
// two pair
result = new HandToPlay(TypeOfHand.TwoPairs, returnCards);
}
else if (IsOnePair(cards, out returnCards))
{
// one pair
result = new HandToPlay(TypeOfHand.OnePair, returnCards);
}
else
{
result = new HandToPlay(TypeOfHand.NoHand, returnCards);
}
return(result);
}
