public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
if (!HandAnalyzerHelpers.IsStraight(playerCards, true) || playerCards.Any(p => boardCards.Any(b => b.RankNumericValue == p.RankNumericValue)) || HandAnalyzerHelpers.IsPair(playerCards, 1))
{
return(false);
}
var sortedCards = boardCards.OrderBy(x => x.RankNumericValue).Distinct().ToList();
if (sortedCards.Min(x => x.RankNumericValue) == Cards.Card.GetRankNumericValue("3"))
{
if (HandAnalyzerHelpers.IsStraight(sortedCards.Take(3)) &&
(boardCards.Count == 3 || (boardCards.Count > 3 && !HandAnalyzerHelpers.IsStraight(sortedCards.Take(4)))))
{
if (sortedCards.Any(x => x.Rank == Cards.Card.PossibleRanksHighCardFirst.First()))
{
return(false);
}
return(playerCards.Any(x => x.Rank == Cards.Card.PossibleRanksHighCardFirst.First()) &&
playerCards.Any(x => x.Rank == Cards.Card.PossibleRanksHighCardFirst.Last()));
}
}
List <int> sequence = new List <int>();
for (int i = sortedCards.Count - 1; i >= 0; i--)
{
if (!sequence.Any() || sequence.Min() - sortedCards.ElementAt(i).RankNumericValue == 1)
{
sequence.Add(sortedCards.ElementAt(i).RankNumericValue);
if (i != 0)
{
continue;
}
}
if (sequence.Count == 3 && (sequence.Min() > playerCards.Max(x => x.RankNumericValue)))
{
if (HandAnalyzerHelpers.IsStraight(sequence.Union(playerCards.Select(x => x.RankNumericValue))))
{
return(true);
}
}
sequence.Clear();
sequence.Add(sortedCards.ElementAt(i).RankNumericValue);
}
return(false);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 2)
{
return(false);
}
if (HandAnalyzerHelpers.IsPair(playerCards, 1))
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (HandAnalyzerHelpers.IsNofKind(allCards, 3) || HandAnalyzerHelpers.IsNofKind(allCards, 4))
{
return(false);
}
var pairs = allCards.GroupBy(x => x.RankNumericValue).Where(x => x.Count() == 2);
if (pairs != null && pairs.Count() > 1)
{
var bottomPair = boardCards.Min(x => x.RankNumericValue);
return(pairs.ElementAt(1).Key == bottomPair &&
playerCards.Any(x => x.RankNumericValue == bottomPair) &&
!playerCards.Any(x => pairs.First().Key == x.RankNumericValue));
}
return(false);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 2)
{
return(false);
}
if (HandAnalyzerHelpers.IsPair(playerCards, 1))
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (HandAnalyzerHelpers.IsNofKind(allCards, 3) || HandAnalyzerHelpers.IsNofKind(allCards, 4))
{
return(false);
}
var topTwo = boardCards.OrderByDescending(x => x.RankNumericValue).Take(2).Distinct();
if (topTwo != null && topTwo.Count() == 2)
{
return(playerCards.All(x => topTwo.Any(t => t.RankNumericValue == x.RankNumericValue)));
}
return(false);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
var allCards = boardCards.ToList();
allCards.AddRange(playerCards);
if (!HandAnalyzerHelpers.IsPair(playerCards, 1) || !HandAnalyzerHelpers.IsNofKind(allCards, 3))
{
return(false);
}
var secondBoardCardRank = boardCards.OrderByDescending(x => x.RankNumericValue).ElementAt(1).RankNumericValue;
if (playerCards.Any(x => x.RankNumericValue == secondBoardCardRank))
{
return(true);
}
return(false);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 2)
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (HandAnalyzerHelpers.IsNofKind(allCards, 3) || HandAnalyzerHelpers.IsNofKind(allCards, 4))
{
return(false);
}
var pairs = allCards.GroupBy(x => x.RankNumericValue).OrderByDescending(x => x.Key).Where(x => x.Count() == 2);
if (pairs != null && pairs.Count() > 1)
{
var bottomTwo = boardCards.OrderBy(x => x.RankNumericValue).Take(2).Distinct();
if (bottomTwo != null && bottomTwo.Count() == 2)
{
return(pairs.Take(2).All(p => bottomTwo.Any(t => t.RankNumericValue == p.Key)) &&
playerCards.All(x => bottomTwo.Any(t => t.RankNumericValue == x.RankNumericValue)));
}
}
return(false);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
var allCards = boardCards.ToList();
allCards.AddRange(playerCards);
if (HandAnalyzerHelpers.IsPair(playerCards, 1) || HandAnalyzerHelpers.IsNofKind(boardCards, 3) || !HandAnalyzerHelpers.IsNofKind(allCards, 3))
{
return(false);
}
var secondSetCard = boardCards.OrderByDescending(x => x.RankNumericValue).ElementAt(1);
if (boardCards.Count(x => x.RankNumericValue == secondSetCard.RankNumericValue) == 2 &&
playerCards.Any(x => x.RankNumericValue == secondSetCard.RankNumericValue))
{
var kicker = playerCards.FirstOrDefault(p => !boardCards.Any(b => b.Rank == p.Rank));
if (kicker != null)
{
return(HandAnalyzerHelpers.IsWeakKicker(kicker));
}
}
return(false);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
var allCards = boardCards.ToList();
allCards.AddRange(playerCards);
if (HandAnalyzerHelpers.IsPair(playerCards, 1) || !HandAnalyzerHelpers.IsNofKind(allCards, 3))
{
return(false);
}
var flopCards = boardCards.GetBoardOnStreet(Street.Flop);
var flopPair = boardCards.GroupBy(x => x.Rank).FirstOrDefault(x => x.Count() == 2);
if (flopPair != null)
{
return(flopPair.Any(f => playerCards.Any(p => p.CardIntValue == f.CardIntValue)));
}
return(false);
}
public void ParseCommunityCards_Preflop()
{
TestBoard(BoardCards.ForPreflop());
}
public void ParseCommunityCards_Flop()
{
TestBoard(BoardCards.ForFlop(Card.Parse("7h"), Card.Parse("Qs"), Card.Parse("3c")));
}
private Expression <Func <Playerstatistic, bool> > GetBoardTexturePredicate()
{
Expression <Func <Playerstatistic, bool> > resultPredicate = null;
var analyzers = BoardTextureAnalyzer.GetDefaultAnalyzers();
if (FlopBoardTextureCollection.Any(x => x.IsChecked))
{
if (resultPredicate == null)
{
resultPredicate = PredicateBuilder.False <Playerstatistic>();
}
var collection = FlopBoardTextureCollection.Where(x => x.IsChecked);
resultPredicate = resultPredicate.Or(p => collection.All(item => analyzers.First(a => a.GetRank() == item.BoardTexture).Analyze(BoardCards.FromCards(p.Board), item)));
}
if (TurnBoardTextureCollection.Any(x => x.IsChecked))
{
if (resultPredicate == null)
{
resultPredicate = PredicateBuilder.False <Playerstatistic>();
}
var collection = TurnBoardTextureCollection.Where(x => x.IsChecked);
resultPredicate = resultPredicate.Or(p => collection.All(item => analyzers.First(a => a.GetRank() == item.BoardTexture).Analyze(BoardCards.FromCards(p.Board), item)));
}
if (RiverBoardTextureCollection.Any(x => x.IsChecked))
{
if (resultPredicate == null)
{
resultPredicate = PredicateBuilder.False <Playerstatistic>();
}
var collection = RiverBoardTextureCollection.Where(x => x.IsChecked);
resultPredicate = resultPredicate.Or(p => collection.All(item => analyzers.First(a => a.GetRank() == item.BoardTexture).Analyze(BoardCards.FromCards(p.Board), item)));
}
return(resultPredicate);
}
private void TestBoard(BoardCards expectedBoard)
{
string handText = SampleHandHistoryRepository.GetCommunityCardsHandHistoryText(PokerFormat.CashGame, Site, expectedBoard.Street);
Assert.AreEqual(expectedBoard, GetParser().ParseCommunityCards(handText));
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 4)
{
return(false);
}
var sortedCards = boardCards.OrderBy(x => x.RankNumericValue).Distinct().ToList();
if (sortedCards.Min(x => x.RankNumericValue) == Cards.Card.GetRankNumericValue("2"))
{
if (HandAnalyzerHelpers.IsStraight(sortedCards.Take(4)) &&
(sortedCards.Count == 4 || (sortedCards.Count > 4 && !HandAnalyzerHelpers.IsStraight(sortedCards.Take(5)))))
{
if (playerCards.Any(x => x.RankNumericValue == Cards.Card.GetRankNumericValue("6")) ||
sortedCards.Any(x => x.Rank == Cards.Card.PossibleRanksHighCardFirst.First()))
{
return(false);
}
return(playerCards.Any(x => x.Rank == Cards.Card.PossibleRanksHighCardFirst.First()));
}
}
List <int> sequence = new List <int>();
for (int i = sortedCards.Count - 1; i >= 0; i--)
{
if (!sequence.Any() || (sequence.Min() - sortedCards.ElementAt(i).RankNumericValue) == 1)
{
sequence.Add(sortedCards.ElementAt(i).RankNumericValue);
if (i != 0)
{
continue;
}
}
if (sequence.Count == 4 && playerCards.Any(x => (sequence.Min() - x.RankNumericValue) == 1) && !playerCards.Any(x => (x.RankNumericValue - sequence.Max()) == 1))
{
return(true);
}
sequence.Clear();
sequence.Add(sortedCards.ElementAt(i).RankNumericValue);
}
return(false);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 4)
{
return(false);
}
return(playerCards.Any(x => HandAnalyzerHelpers.IsOneCardStraight(x, boardCards)));
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 4)
{
return(false);
}
var ten = Cards.Card.GetRankNumericValue("T");
var ace = Cards.Card.GetRankNumericValue("A");
var sortedBoardRanks = boardCards.Select(x => x.RankNumericValue).Where(x => x >= ten && x <= ace).Distinct().ToList();
sortedBoardRanks.Sort();
if (sortedBoardRanks.Count() == 4)
{
for (int i = ten; i <= ace; i++)
{
if (sortedBoardRanks.Contains(i))
{
continue;
}
if (playerCards.Any(x => x.RankNumericValue == i))
{
return(true);
}
else
{
return(false);
}
}
}
return(false);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
var allCards = boardCards.ToList();
allCards.AddRange(playerCards);
if (!HandAnalyzerHelpers.IsPair(playerCards, 1) || !HandAnalyzerHelpers.IsNofKind(allCards, 3))
{
return(false);
}
var bottomBoardCardRank = boardCards.Min(x => x.RankNumericValue);
if (playerCards.Any(x => x.RankNumericValue == bottomBoardCardRank))
{
return(true);
}
return(false);
}
public void ParseCommunityCards_Turn()
{
TestBoard(BoardCards.ForTurn(Card.Parse("Kc"), Card.Parse("Ah"), Card.Parse("7c"), Card.Parse("3d")));
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
var allCards = boardCards.ToList();
allCards.AddRange(playerCards);
if (HandAnalyzerHelpers.IsPair(playerCards, 1) || HandAnalyzerHelpers.IsNofKind(boardCards, 3) || !HandAnalyzerHelpers.IsNofKind(allCards, 3))
{
return(false);
}
bool isThreeOfAKind = boardCards.Where(x => x.RankNumericValue == playerCards.ElementAt(0).RankNumericValue).Count() == 2 ||
boardCards.Where(x => x.RankNumericValue == playerCards.ElementAt(1).RankNumericValue).Count() == 2;
if (isThreeOfAKind)
{
var kicker = playerCards.FirstOrDefault(p => !boardCards.Any(b => b.Rank == p.Rank));
if (kicker != null)
{
return(HandAnalyzerHelpers.IsDecentKicker(kicker));
}
}
return(false);
}
public void ParseCommunityCards_River()
{
TestBoard(BoardCards.ForRiver(Card.Parse("5d"), Card.Parse("Ks"), Card.Parse("7c"), Card.Parse("Jc"), Card.Parse("7d")));
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
var allCards = boardCards.ToList();
allCards.AddRange(playerCards);
if (HandAnalyzerHelpers.IsPair(playerCards, 1) || !HandAnalyzerHelpers.IsNofKind(allCards, 3) || HandAnalyzerHelpers.IsNofKind(boardCards, 3))
{
return(false);
}
var kicker = playerCards.FirstOrDefault(p => !boardCards.Any(b => b.Rank == p.Rank));
if (kicker != null)
{
return(HandAnalyzerHelpers.IsWeakKicker(kicker));
}
return(false);
}
public SummaryBoardLine(string line)
{
string cardBuffer = line.Split('[')[1].Split(']')[0].Trim();
Cards = new BoardCards(CardParser.ParseCards(cardBuffer));
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (boardCards == null || boardCards.Count < 3)
{
return(false);
}
return(HandAnalyzerHelpers.IsNofKind(boardCards, 3));
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
return(true);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 2)
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (HandAnalyzerHelpers.IsNofKind(allCards, 3) || HandAnalyzerHelpers.IsNofKind(allCards, 4))
{
return(false);
}
var pairs = allCards.GroupBy(x => x.RankNumericValue).Where(x => x.Count() == 2);
if (pairs != null && pairs.Count() > 1)
{
return(boardCards.Any(x => x.RankNumericValue > pairs.Max(p => p.Max(m => m.RankNumericValue))));
}
return(false);
}
/// <summary>
/// Returns a prediction of the opponent's deck classes, i.e. set of classes and there probability,
/// based on the board cards of the opponent.
/// </summary>
/// <param name="opponent">the controller of the opponent</param>
/// <param name="boardCards">the board cards of the opponent</param>
/// <returns>a set of classes and there probability</returns>
private Dictionary <CardClass, double> predictDeckClasses(Controller opponent, BoardCards boardCards)
{
int denominator = boardCards.Count;
// fetch all classes of the opponent's board cards
var boardClasses = new List <CardClass>();
boardClasses.AddRange(boardCards.Cards
.Select(c => c.Class)
.ToList());
// add the class of the opponent's hero
CardClass heroClass = opponent.HeroClass;
if (!boardClasses.Contains(heroClass))
{
boardClasses.Add(heroClass);
// increment denominator because the hero is not part of the opponent's board
denominator++;
}
var deckClasses = new Dictionary <CardClass, double>();
boardClasses.GroupBy(c => c)
// calculate card class distribution over all already drawn cards
.Select(c => new KeyValuePair <CardClass, double>(c.Key, ((double)c.Count() / denominator)))
.OrderByDescending(c => c.Key)
.ToList().ForEach(c => deckClasses.Add(c.Key, c.Value));
return(deckClasses);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 2)
{
return(false);
}
if (!HandAnalyzerHelpers.IsPair(playerCards, 1))
{
return(false);
}
var allCards = boardCards.ToList();
allCards.AddRange(playerCards);
var pairs = allCards.GroupBy(x => x.RankNumericValue).Where(x => x.Count() == 2);
if (pairs != null && pairs.Count() > 1)
{
return(playerCards.First().RankNumericValue > boardCards.Max(x => x.RankNumericValue));
}
return(false);
}
/// <summary>
/// Returns a prediction of the opponent's hand cards, i.e. set of cards and there probability,
/// based on the bi-gram map and cards which haven been played the opponent.
/// </summary>
/// <param name="cardCount">the number of sets which will by predicted</param>
/// <param name="simulationGame">the game the prediction is performed on</param>
/// <param name="playedCards">the cards which have been played by the opponent</param>
/// <param name="boardCards">the board cards of the opponent</param>
/// <param name="classPrediction">the prediction of the deck classes of the opponent</param>
/// <returns>the set of cards and there probability</returns>
private List <PredictedCards> predictCards(int cardCount, POGame.POGame simulationGame, PlayedCards playedCards,
BoardCards boardCards, Dictionary <CardClass, double> classPrediction)
{
List <Dictionary <string, double> > occMaps = getOccurenceMaps(playedCards);
var combinedOccMap = new Dictionary <string, double>();
foreach (Dictionary <string, double> occMap in occMaps)
{
occMap.ToList().ForEach(o => {
string cardId = o.Key;
double cardValue = o.Value;
if (combinedOccMap.ContainsKey(cardId))
{
// greedy approach
if (combinedOccMap[cardId] < cardValue)
{
combinedOccMap[cardId] = cardValue;
}
}
else
{
combinedOccMap.Add(cardId, cardValue);
}
});
}
Dictionary <Card, double> playableCards = convertToCardMap(combinedOccMap, classPrediction);
// get number of cards in relation to the class distribution of already drawn cards
var tempPredictedCardGroups = new List <PredictedCards>();
classPrediction.ToList().ForEach(c =>
{
// filter cards if they have already been exhausted or not
var filterdPlayableCards = new PredictedCards(
playableCards.Where(p => p.Key.Class == c.Key)
.Where(p =>
{
if (p.Key.Rarity == Rarity.LEGENDARY)
{
return(boardCards.Cards
.Count(b => b == p.Key) < 1);
}
else
{
return(boardCards.Cards
.Count(b => b == p.Key) < 2);
}
}).ToList());
int share = (int)(c.Value * cardCount);
var predictedCards = new PredictedCards(filterdPlayableCards
.CardEntries.Take(share)
.ToList());
tempPredictedCardGroups.Add(predictedCards);
});
var combinedPredictedCards = new PredictedCards(
tempPredictedCardGroups.SelectMany(g => g.CardEntries)
.ToList());
double sum = combinedPredictedCards.Sum;
var predictedCardGroups = new List <PredictedCards>();
foreach (PredictedCards group in tempPredictedCardGroups)
{
var newGroup = new PredictedCards();
group.CardEntries
// sort list
.OrderByDescending(c => c.Value)
.ToList().ForEach(c => newGroup.Add(c.Key, (c.Value / sum)));
predictedCardGroups.Add(newGroup);
}
return(predictedCardGroups);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (boardCards == null || playerCards == null || playerCards.Count() == 0 || boardCards.Count == 0)
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (HandAnalyzerHelpers.IsNofKind(allCards, 3) || HandAnalyzerHelpers.IsNofKind(allCards, 4))
{
return(false);
}
return(!HandAnalyzerHelpers.IsPair(playerCards, 1) &&
!playerCards.Any(p => boardCards.Any(b => b.Rank == p.Rank)) &&
HandAnalyzerHelpers.IsPair(boardCards, 2));
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() == 0)
{
return(false);
}
if (HandAnalyzerHelpers.IsPair(playerCards, 1))
{
return(false);
}
var trips = boardCards.GroupBy(x => x.Rank).FirstOrDefault(x => x.Count() == 3);
if (trips != null)
{
return(playerCards.Any(x => x.Rank == trips.Key));
}
return(false);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 2)
{
return(false);
}
if (HandAnalyzerHelpers.IsPair(playerCards, 1))
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (HandAnalyzerHelpers.IsNofKind(allCards, 3) || HandAnalyzerHelpers.IsNofKind(allCards, 4))
{
return(false);
}
var pairs = allCards.GroupBy(x => x.RankNumericValue).OrderByDescending(x => x.Key).Where(x => x.Count() == 2);
var sortedBoard = boardCards.OrderBy(x => x.RankNumericValue);
if (pairs != null && pairs.Count() > 1 && sortedBoard != null && sortedBoard.Count() >= 2)
{
pairs = pairs.Take(2);
var bottomTwo = boardCards.OrderBy(x => x.RankNumericValue).Take(2).Distinct();
if (bottomTwo != null && bottomTwo.Count() == 2)
{
return(pairs.Any(x => x.Key == sortedBoard.First().RankNumericValue) &&
pairs.Any(x => x.Key == sortedBoard.Last().RankNumericValue) &&
playerCards.Any(x => x.RankNumericValue == sortedBoard.First().RankNumericValue) &&
playerCards.Any(x => x.RankNumericValue == sortedBoard.Last().RankNumericValue));
}
}
return(false);
}
public bool Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
if (playerCards.Any(p => boardCards.Any(b => b.RankNumericValue == p.RankNumericValue)) || HandAnalyzerHelpers.IsPair(playerCards, 1))
{
return(false);
}
var sortedBoard = boardCards.OrderBy(x => x.RankNumericValue).ToList();
if (sortedBoard.Any(x => x.Rank == Cards.Card.PossibleRanksHighCardFirst.First()) &&
sortedBoard.Any(x => x.Rank == Cards.Card.PossibleRanksHighCardFirst.Last()))
{
sortedBoard.Insert(0, new Cards.Card("A", "c"));
}
for (int i = sortedBoard.Count() - 1; i >= 2; i--)
{
var curCards = sortedBoard.Skip(i - 2).ToList();
if (curCards.Count() >= 3)
{
curCards.AddRange(playerCards);
curCards = curCards.OrderByDescending(x => x.RankNumericValue).Take(5).ToList();
if (HandAnalyzerHelpers.IsStraight(curCards, true))
{
return(playerCards.All(p => curCards.Any(c => c.RankNumericValue == p.RankNumericValue)));
}
}
}
return(false);
}
