private void PairCheck(GameCard firstCard, GameCard secondCard, GameCard[] cardsOnTable, IPlayer player)
{
int firstCardPairCount = cardsOnTable.Count(card => firstCard.Rank == card.Rank);
int secondCardPairCount = cardsOnTable.Count(card => secondCard.Rank == card.Rank);
int pairsOnTableCount = cardsOnTable
.GroupBy(card => card.Rank)
.Select(group => new { Count = @group.Count() })
.Count(group => @group.Count == 2);
if ((firstCardPairCount == 1 ^ secondCardPairCount == 1) &&
firstCard.Rank == secondCard.Rank)
{
if (pairsOnTableCount != 1)
{
return;
}
}
if (firstCardPairCount == 1)
{
player.PokerHandMultiplier = 0;
player.CardPower = firstCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
if (secondCardPairCount == 1)
{
player.PokerHandMultiplier = 0;
player.CardPower = secondCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
var pairOnTableRank = cardsOnTable
.GroupBy(card => card.Rank)
.Select(group => new
{
Rank = @group.Key,
Count = @group.Count()
})
.Where(group => @group.Count == 1)
.Select(newGroup => newGroup.Rank)
.First();
player.PokerHandMultiplier = 0;
player.CardPower = pairOnTableRank * 4 + player.PokerHandMultiplier * 100;
}
private void TwoPairCheck(GameCard firstCard, GameCard secondCard, GameCard[] cardsOnTable, IPlayer player)
{
int firstCardPairCount = cardsOnTable.Count(card => firstCard.Rank == card.Rank);
int secondCardPairCount = cardsOnTable.Count(card => secondCard.Rank == card.Rank);
if (firstCardPairCount > 1 || secondCardPairCount > 1)
{
return;
}
if (firstCardPairCount == 1 && secondCardPairCount == 1 && firstCard.Rank == secondCard.Rank)
{
return;
}
int pairsOnTable = 0;
int highestTablePairRank = 0;
for (int startCardIndex = 0; startCardIndex < cardsOnTable.Length - 1; startCardIndex++)
{
int pairCount = 0;
for (int endCardIndex = cardsOnTable.Length - 1; endCardIndex > 0; endCardIndex--)
{
if (endCardIndex == startCardIndex)
{
continue;
}
if (cardsOnTable[startCardIndex].Rank != cardsOnTable[endCardIndex].Rank)
{
continue;
}
pairCount++;
if (highestTablePairRank < cardsOnTable[startCardIndex].Rank)
{
highestTablePairRank = cardsOnTable[startCardIndex].Rank;
}
}
if (pairCount > 1)
{
return;
}
if (pairCount == 1)
{
pairsOnTable++;
}
}
switch (pairsOnTable)
{
case 0:
if (firstCardPairCount == 1 && secondCardPairCount == 1)
{
player.PokerHandMultiplier = 2;
player.CardPower = firstCard.Rank * 2 + secondCard.Rank * 2 + player.PokerHandMultiplier * 100;
}
break;
case 1:
if (firstCard.Rank == secondCard.Rank)
{
player.PokerHandMultiplier = 2;
player.CardPower = firstCard.Rank * 2 + highestTablePairRank * 2 + player.PokerHandMultiplier * 100;
}
else if (firstCardPairCount == 1 && secondCardPairCount != 1)
{
player.PokerHandMultiplier = 2;
player.CardPower = firstCard.Rank * 2 + highestTablePairRank * 2 + player.PokerHandMultiplier * 100;
}
else if (secondCardPairCount == 1 && firstCardPairCount != 1)
{
player.PokerHandMultiplier = 2;
player.CardPower = secondCard.Rank * 2 + highestTablePairRank * 2 + player.PokerHandMultiplier * 100;
}
else if (secondCardPairCount == 1 && firstCardPairCount == 1)
{
int highestRank;
int secondHighestRank;
if (firstCard.Rank > secondCard.Rank)
{
highestRank = firstCard.Rank;
secondHighestRank = secondCard.Rank;
}
else
{
highestRank = secondCard.Rank;
secondHighestRank = firstCard.Rank;
}
if (secondHighestRank < highestTablePairRank)
{
secondHighestRank = highestTablePairRank;
}
player.PokerHandMultiplier = 2;
player.CardPower = highestRank * 2 + secondHighestRank * 2 + player.PokerHandMultiplier * 100;
}
break;
case 2:
if (firstCard.Rank == secondCard.Rank)
{
int highestCardHandOrTable = Math.Max(highestTablePairRank, Math.Max(firstCard.Rank, secondCard.Rank));
player.PokerHandMultiplier = 2;
player.CardPower = highestCardHandOrTable * 4 + player.PokerHandMultiplier * 100;
}
else if (firstCardPairCount == 1)
{
int highestCardHandOrTable = firstCard.Rank > highestTablePairRank ? firstCard.Rank : highestTablePairRank;
player.PokerHandMultiplier = 2;
player.CardPower = highestCardHandOrTable * 4 + player.PokerHandMultiplier * 100;
}
else if (secondCardPairCount == 1)
{
int highestCardHandOrTable = secondCard.Rank > highestTablePairRank ? secondCard.Rank : highestTablePairRank;
player.PokerHandMultiplier = 2;
player.CardPower = highestCardHandOrTable * 4 + player.PokerHandMultiplier * 100;
}
else
{
player.PokerHandMultiplier = 2;
player.CardPower = highestTablePairRank * 4 + player.PokerHandMultiplier * 100;
}
break;
}
}
private void StraightCheck(GameCard firstCard, GameCard secondCard, GameCard[] cardsOnTable, IPlayer player)
{
int firstCardPairs = cardsOnTable.Count(card => firstCard.Rank == card.Rank);
int secondCardPairs = cardsOnTable.Count(card => secondCard.Rank == card.Rank);
List<int> allCards = new List<int>();
if (firstCardPairs == 0)
{
if (firstCard.Rank == 14)
{
allCards.Add(firstCard.Rank);
allCards.Add(1);
}
else
{
allCards.Add(firstCard.Rank);
}
}
if (secondCardPairs == 0)
{
if (secondCard.Rank == 14)
{
allCards.Add(secondCard.Rank);
allCards.Add(1);
}
else
{
allCards.Add(firstCard.Rank);
}
}
if (cardsOnTable.Any(card => card.Rank == 14))
{
allCards.Add(1);
}
allCards.AddRange(cardsOnTable.Select(card => card.Rank));
allCards.Sort();
int countConsecutives = 0;
int highestCardRankInStreight = 0;
for (int startCard = 0; startCard < allCards.Count - 1; startCard++)
{
if (allCards[startCard] + 1 == allCards[startCard + 1])
{
countConsecutives++;
if (countConsecutives >= 5)
{
highestCardRankInStreight = allCards[startCard + 1];
}
}
}
if (countConsecutives < 5)
{
return;
}
player.PokerHandMultiplier = 4;
player.CardPower = highestCardRankInStreight * 4 + player.PokerHandMultiplier * 100;
}
private void ThreeOfAKindCheck(GameCard firstCard, GameCard secondCard, GameCard[] cardsOnTable, IPlayer player)
{
int firstCardThreeOfAKindCount = cardsOnTable.Count(card => firstCard.Rank == card.Rank);
int secondCardThreeOfAKindCount = cardsOnTable.Count(card => secondCard.Rank == card.Rank);
if (firstCardThreeOfAKindCount > 2 || secondCardThreeOfAKindCount > 2)
{
return;
}
if (firstCardThreeOfAKindCount == 2 && secondCardThreeOfAKindCount == 2 && firstCard.Rank == secondCard.Rank)
{
return;
}
GameCard highestCard = this.GetHighestCardInHand(firstCard, secondCard);
if (firstCardThreeOfAKindCount == 2 || secondCardThreeOfAKindCount == 2)
{
player.PokerHandMultiplier = 3;
if (firstCardThreeOfAKindCount == 2 && secondCardThreeOfAKindCount != 2)
{
player.CardPower = firstCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
else if (firstCardThreeOfAKindCount != 2 && secondCardThreeOfAKindCount == 2)
{
player.CardPower = secondCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
else
{
player.CardPower = highestCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
}
if (firstCardThreeOfAKindCount == 1 &&
secondCardThreeOfAKindCount == 1 &&
firstCard.Rank == secondCard.Rank)
{
player.PokerHandMultiplier = 3;
player.CardPower = firstCard.Rank * 4 + player.PokerHandMultiplier * 100;
}
var tableCardsTreeOfAKind = cardsOnTable
.GroupBy(card => card.Rank)
.Select(group => new { Rank = @group.Key, Count = @group.Count() })
.OrderByDescending(group => @group.Count)
.First();
if (tableCardsTreeOfAKind.Count != 3)
{
return;
}
if (firstCardThreeOfAKindCount == 1 &&
secondCardThreeOfAKindCount == 1 &&
firstCard.Rank == secondCard.Rank)
{
int highestCardHandOrTable = tableCardsTreeOfAKind.Rank > firstCard.Rank ? tableCardsTreeOfAKind.Rank : firstCard.Rank;
player.PokerHandMultiplier = 3;
player.CardPower = highestCardHandOrTable * 4 + player.PokerHandMultiplier * 100;
}
if (firstCardThreeOfAKindCount == 0 &&
secondCardThreeOfAKindCount == 0)
{
player.PokerHandMultiplier = 3;
player.CardPower = tableCardsTreeOfAKind.Rank * 4 + player.PokerHandMultiplier * 100;
}
}
private void StraightFlushCheck(GameCard firstCard, GameCard secondCard, GameCard[] cardsOnTable, IPlayer player)
{
int firstCardPairs = cardsOnTable.Count(card => firstCard.Rank == card.Rank);
int secondCardPairs = cardsOnTable.Count(card => secondCard.Rank == card.Rank);
SortedDictionary<int, CardSuit> allCards = new SortedDictionary<int, CardSuit>();
if (firstCard.Rank == 14)
{
allCards[firstCard.Rank] = firstCard.Suit;
allCards[1] = firstCard.Suit;
}
else
{
allCards[firstCard.Rank] = firstCard.Suit;
}
if (secondCard.Rank == 14)
{
allCards[secondCard.Rank] = secondCard.Suit;
allCards[1] = secondCard.Suit;
}
else
{
allCards[secondCard.Rank] = secondCard.Suit;
}
foreach (GameCard card in cardsOnTable)
{
if (card.Rank == 14)
{
allCards[card.Rank] = card.Suit;
allCards[1] = card.Suit;
}
else
{
allCards[card.Rank] = card.Suit;
}
}
List<int> allCardsKeys = new List<int>(allCards.Keys);
int streightFlushCardsCount = 0;
int streightFlushCardsHighestRank = 0;
for (int index = 0; index < allCardsKeys.Count - 1; index++)
{
if (allCardsKeys[index] + 1 == allCardsKeys[index + 1] && allCards[allCardsKeys[index]] == allCards[allCardsKeys[index + 1]])
{
streightFlushCardsCount++;
if (streightFlushCardsCount >= 5)
{
streightFlushCardsHighestRank = allCardsKeys[index + 1];
}
}
}
if (streightFlushCardsCount < 5)
{
return;
}
player.PokerHandMultiplier = 8;
player.CardPower = streightFlushCardsHighestRank * 4 + player.PokerHandMultiplier * 100;
}
