public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (!HandAnalyzerHelpers.IsFlushDraw(playerCards, boardCards, 1))
{
return(false);
}
var drawSuit = boardCards.GroupBy(x => x.CardSuit).FirstOrDefault(x => x.Count() == 3)?.Key;
return((drawSuit != null) && HandAnalyzerHelpers.IsWeakKicker(playerCards.OrderByDescending(x => x.Rank).First(x => x.CardSuit == drawSuit)));
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (boardCards == null || boardCards.Count() == 0)
{
return(false);
}
if (HandAnalyzerHelpers.IsFlush(boardCards) && HandAnalyzerHelpers.IsStraight(boardCards, true))
{
return(true);
}
return(false);
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || !boardCards.Any())
{
return(false);
}
if (!HandAnalyzerHelpers.HasPair(playerCards, 1))
{
return(false);
}
return(boardCards.GroupBy(x => x.Rank).Any(g => (g.Count() == 2) && (g.Key == playerCards.First().Rank)));
}
private Expression <Func <Playerstatistic, bool> > GetHandPredicate(QuickFilterHandTypeEnum handType)
{
switch (handType)
{
case QuickFilterHandTypeEnum.None:
break;
case QuickFilterHandTypeEnum.StraightDrawOnFlop:
return(PredicateBuilder.Create <Playerstatistic>(x => CardHelper.IsStreetAvailable(x.Board, Street.Flop) &&
Hand.IsStraightDraw(x.Cards, BoardCards.FromCards(x.Board).GetBoardOnStreet(Street.Flop).ToString(), string.Empty)));
case QuickFilterHandTypeEnum.FlushDrawOnFlop:
return(PredicateBuilder.Create <Playerstatistic>(x => CardHelper.IsStreetAvailable(x.Board, Street.Flop) &&
Hand.IsFlushDraw(x.Cards, BoardCards.FromCards(x.Board).GetBoardOnStreet(Street.Flop).ToString(), string.Empty)));
case QuickFilterHandTypeEnum.MarginalHand:
return(PredicateBuilder.Create <Playerstatistic>(x => HandAnalyzerHelpers.IsMarginalHand(x.Cards)));
case QuickFilterHandTypeEnum.LessThanMidPairOnRiver:
return(PredicateBuilder.Create <Playerstatistic>(x => CardHelper.IsStreetAvailable(x.Board, Street.River) &&
new HandAnalyzer(new IAnalyzer[] { new LessThanMidPairAnalyzer() })
.Analyze(CardGroup.Parse(x.Cards), BoardCards.FromCards(x.Board).GetBoardOnStreet(Street.River))
.GetRank() == ShowdownHands.LessThanMidPair));
case QuickFilterHandTypeEnum.FlopTPOrBetter:
return(PredicateBuilder.Create <Playerstatistic>(x => CardHelper.IsStreetAvailable(x.Board, Street.Flop) &&
new HandAnalyzer(new IAnalyzer[] { new LessThanMidPairAnalyzer() })
.Analyze(CardGroup.Parse(x.Cards), BoardCards.FromCards(x.Board).GetBoardOnStreet(Street.Flop))
.GetRank() == ShowdownHands.LessThanMidPair));
case QuickFilterHandTypeEnum.PremiumHand:
return(PredicateBuilder.Create <Playerstatistic>(x => HandAnalyzerHelpers.IsPremiumHand(x.Cards)));
case QuickFilterHandTypeEnum.NonPremiumHand:
return(PredicateBuilder.Create <Playerstatistic>(x => !HandAnalyzerHelpers.IsPremiumHand(x.Cards)));
case QuickFilterHandTypeEnum.BluffRange:
return(PredicateBuilder.Create <Playerstatistic>(x => HandAnalyzerHelpers.IsBluffRange(x.Cards)));
default:
break;
}
return(PredicateBuilder.True <Playerstatistic>());
}
public virtual bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || !boardCards.Any())
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (HandAnalyzerHelpers.IsNoOfKind(allCards, 3) || HandAnalyzerHelpers.IsNoOfKind(allCards, 4))
{
return(false);
}
return(HandAnalyzerHelpers.HasPair(playerCards, 1) && HandAnalyzerHelpers.HasPair(boardCards, 1));
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
if (playerCards.Any(p => boardCards.Any(b => b.Rank == p.Rank)))
{
return(false);
}
var rankList = HandAnalyzerHelpers.CombineCardLists(playerCards, boardCards).Where(x => x.Rank != (int)DataTypes.Card.GetCardRank("A")).Select(x => x.Rank).Distinct().ToList();
rankList.Sort();
List <int> straightDraw = new List <int>();
for (int i = 0; i < rankList.Count; i++)
{
if (!straightDraw.Any() || (rankList[i] == straightDraw.Last() + 1))
{
straightDraw.Add(rankList[i]);
continue;
}
if (straightDraw.Count == 4)
{
if (HandAnalyzerHelpers.IsStraight(straightDraw) &&
playerCards.Any(x => straightDraw.Contains(x.Rank)) &&
playerCards.Any(x => !straightDraw.Contains(x.Rank)))
{
return(true);
}
}
straightDraw.Clear();
straightDraw.Add(rankList[i]);
}
return(false);
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count != 2 || !boardCards.Any())
{
return(false);
}
if (HandAnalyzerHelpers.HasPair(playerCards, 1))
{
return(false);
}
if (!HandAnalyzerHelpers.IsNoOfKind(boardCards, 3))
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(playerCards, boardCards);
if (HandAnalyzerHelpers.IsNoOfKind(allCards, 4))
{
return(false);
}
var groupedCards = allCards.GroupBy(x => x.Rank).OrderByDescending(x => x.Key);
var trips = groupedCards.FirstOrDefault(x => x.Count() == 3);
if (trips != null)
{
var pair = groupedCards.Where(x => x.Key != trips.Key).Where(x => x.Count() >= 2);
if (playerCards.Any(x => pair.Any(y => y.Key == x.Rank)))
{
return(true);
}
}
return(false);
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
if (playerCards.Any(p => boardCards.Any(b => b.Rank == p.Rank)) ||
HandAnalyzerHelpers.HasPair(playerCards, 1))
{
return(false);
}
var sortedBoard = boardCards.OrderBy(x => x.Rank);
for (int i = sortedBoard.Count() - 1; i >= 2; i--)
{
var curCards = sortedBoard.Skip(i - 2);
if (curCards.Count() >= 3)
{
curCards = curCards.Take(3);
var nutStraight = GetNutStraightForCards(curCards);
if (nutStraight != null)
{
var requiredPocketCards = nutStraight.Where(x => !curCards.Any(c => c.Rank == x));
if (playerCards.All(x => requiredPocketCards.Contains(x.Rank)))
{
return(true);
}
else
{
return(false);
}
}
}
}
return(false);
}
public int Analyze(string boardCards, Street targetStreet)
{
var cards = BoardTextureAnalyzerHelpers.ParseStringSequenceOfCards(boardCards);
if (string.IsNullOrEmpty(boardCards) || !BoardTextureAnalyzerHelpers.IsStreetAvailable(cards, targetStreet))
{
return(0);
}
int numberOfOpenEndedStraights = 0;
var orderedRanks = BoardTextureAnalyzerHelpers.GetOrderedBoardNumericRanks(cards, targetStreet);
if (orderedRanks.Count < 2)
{
return(0);
}
int firstRank = orderedRanks.Max() + 2;
while (firstRank > orderedRanks.Min() - 2)
{
firstRank = BoardTextureAnalyzerHelpers.GetHighestUniqueRankNumberForList(orderedRanks, firstRank);
var secondRank = BoardTextureAnalyzerHelpers.GetHighestUniqueRankNumberForList(orderedRanks, firstRank - 1);
if (secondRank <= 0)
{
break;
}
var connectedList = new List <int>(orderedRanks);
connectedList.Add(secondRank);
connectedList = HandAnalyzerHelpers.GetConnectedCards(firstRank, connectedList);
if (connectedList.Count > 4)
{
numberOfOpenEndedStraights += HandAnalyzerHelpers.IsStraight(connectedList.OrderByDescending(x => x).Take(5).ToList()) ? 1 : 0;
}
firstRank--;
}
return(numberOfOpenEndedStraights);
}
public bool Analyze(BoardCards boardCards, BoardTextureItem boardTexture)
{
var boardTextureItem = boardTexture as StraightBoardTextureItem;
if (boardTextureItem == null || !CardHelper.IsStreetAvailable(boardCards.ToString(), boardTextureItem.TargetStreet))
{
return(false);
}
int numberOfOpenEndedStraights = 0;
var orderedRanks = BoardTextureAnalyzerHelpers.GetOrderedBoardNumericRanks(boardCards, boardTextureItem);
if (orderedRanks.Count < 2)
{
return(false);
}
int firstRank = orderedRanks.Max() + 2;
while (firstRank > orderedRanks.Min() - 2)
{
firstRank = BoardTextureAnalyzerHelpers.GetHighestUniqueRankNumberForList(orderedRanks, firstRank);
var secondRank = BoardTextureAnalyzerHelpers.GetHighestUniqueRankNumberForList(orderedRanks, firstRank - 1);
if (secondRank <= 0)
{
break;
}
var connectedList = new List <int>(orderedRanks);
connectedList.Add(secondRank);
connectedList = HandAnalyzerHelpers.GetConnectedCards(firstRank, connectedList);
if (connectedList.Count > 4)
{
numberOfOpenEndedStraights += HandAnalyzerHelpers.IsStraight(connectedList.OrderByDescending(x => x).Take(5)) ? 1 : 0;
}
firstRank--;
}
return(BoardTextureAnalyzerHelpers.CheckEquality(boardTextureItem.SelectedSign.Key, numberOfOpenEndedStraights, boardTextureItem.SelectedNumber));
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || !boardCards.Any())
{
return(false);
}
List <DataTypes.Card> consideredCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (HandAnalyzerHelpers.HasPair(playerCards, 1) && HandAnalyzerHelpers.HasPair(consideredCards, 1))
{
if (boardCards.Count(x => x.Rank > playerCards.First().Rank) == 1)
{
return(true);
}
}
return(false);
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || !boardCards.Any())
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (!HandAnalyzerHelpers.HasPair(playerCards, 1) || !HandAnalyzerHelpers.IsNoOfKind(allCards, 3))
{
return(false);
}
var lowCardRank = boardCards.Min(x => x.Rank);
return(playerCards.Any(x => x.Rank == lowCardRank));
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || !boardCards.Any())
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (!HandAnalyzerHelpers.HasPair(playerCards, 1) || !HandAnalyzerHelpers.IsNoOfKind(allCards, 3))
{
return(false);
}
var secondBoardCardRank = boardCards.OrderByDescending(x => x.Rank).Distinct().ElementAt(1).Rank;
return(playerCards.Any(x => x.Rank == secondBoardCardRank));
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || !boardCards.Any())
{
return(false);
}
List <DataTypes.Card> consideredCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (HandAnalyzerHelpers.HasPair(playerCards, 1) &&
HandAnalyzerHelpers.HasPair(consideredCards, 1) &&
!new PocketPairOverpairAnalyzer().Analyze(playerCards, allBoardCards, targetStreet) &&
!new PocketPairSecondPairAnalyzer().Analyze(playerCards, allBoardCards, targetStreet))
{
return(true);
}
return(false);
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 4)
{
return(false);
}
if (!HandAnalyzerHelpers.IsFlush(playerCards))
{
return(false);
}
var sortedBoard = boardCards.OrderBy(x => x.Rank);
for (int i = 0; i < sortedBoard.Count() - 4; i++)
{
var cards = sortedBoard.Take(4).ToList();
if (!HandAnalyzerHelpers.IsFlush(cards))
{
return(false);
}
foreach (var card in playerCards)
{
var straightFlushCards = new List <DataTypes.Card>(cards);
straightFlushCards.Add(card);
if (HandAnalyzerHelpers.IsFlush(straightFlushCards) && HandAnalyzerHelpers.IsStraight(straightFlushCards, true))
{
return(true);
}
}
}
return(false);
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
if (playerCards.Any(p => boardCards.Any(b => b.Rank == p.Rank)) || HandAnalyzerHelpers.HasPair(playerCards, 1))
{
return(false);
}
var sortedBoard = boardCards.OrderBy(x => x.Rank).ToList();
if (sortedBoard.Any(x => x.Rank == (int)DataTypes.Card.GetCardRank("A")) &&
sortedBoard.Any(x => x.Rank == (int)DataTypes.Card.GetCardRank("2")))
{
sortedBoard.Insert(0, new DataTypes.Card("Ac"));
}
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.Rank).Take(5).ToList();
if (HandAnalyzerHelpers.IsStraight(curCards, true))
{
return(playerCards.All(p => curCards.Any(c => c.Rank == p.Rank)));
}
}
}
return(false);
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || !boardCards.Any())
{
return(false);
}
if (HandAnalyzerHelpers.HasPair(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(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 4)
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
var suitGroup = allCards.GroupBy(x => x.CardSuit);
if (suitGroup.Any(g => g.Count() >= 5))
{
var flushBoardCards = suitGroup.First(g => g.Count() >= 5).OrderByDescending(x => x.Rank).Take(5);
if (playerCards.All(x => flushBoardCards.All(f => f.CardSuit != x.CardSuit)))
{
return(HandAnalyzerHelpers.IsWeakKicker(flushBoardCards.First()));
}
}
return(false);
}
public virtual bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || !boardCards.Any())
{
return(false);
}
List <DataTypes.Card> consideredCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (HandAnalyzerHelpers.HasPair(playerCards, 1) || !HandAnalyzerHelpers.HasPair(consideredCards, 1))
{
return(false);
}
if (playerCards.Any(c => c.Rank == boardCards.Max(x => x.Rank)))
{
return(true);
}
return(false);
}
private bool CheckIfHasStraight(List <DataTypes.Card> cards)
{
if (cards.Count < 5)
{
return(false);
}
//bool flag = false;
for (int i = 0; i < cards.Count - 4; i++)
{
if (HandAnalyzerHelpers.IsStraight(cards.GetRange(i, 5), true) ||
HandAnalyzerHelpers.IsStraight(cards.GetRange(i, 5), false))
{
return(true);
//flag = true;
//break;
}
}
//if (flag)
// return false;
return(false);
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
return(HandAnalyzerHelpers.IsFlushDraw(playerCards, boardCards, 2, isBackdoor: true));
}
public bool Analyze(BoardCards boardCards, BoardTextureItem boardTexture)
{
var boardTextureItem = boardTexture as StraightBoardTextureItem;
if (boardTextureItem == null || !CardHelper.IsStreetAvailable(boardCards.ToString(), boardTextureItem.TargetStreet))
{
return(false);
}
int numberOfOpenEndedStraights = 0;
var orderedRanks = BoardTextureAnalyzerHelpers.GetOrderedBoardNumericRanks(boardCards, boardTextureItem);
if (orderedRanks.Count < 2)
{
return(false);
}
int firstRank = BoardTextureAnalyzerHelpers.GetHighestUniqueRankNumberForList(orderedRanks, orderedRanks.Max() + 2);
int initFirstRank = firstRank;
int nutRank = 0;
bool isNutFound = false;
while (firstRank > orderedRanks.Min() - 2)
{
firstRank = BoardTextureAnalyzerHelpers.GetHighestUniqueRankNumberForList(orderedRanks, firstRank);
if (isNutFound && firstRank <= nutRank)
{
break;
}
var secondRank = BoardTextureAnalyzerHelpers.GetHighestUniqueRankNumberForList(orderedRanks, firstRank - 1);
if (secondRank <= 0)
{
break;
}
var connectedList = new List <int>(orderedRanks);
connectedList.Add(secondRank);
connectedList = HandAnalyzerHelpers.GetConnectedCards(firstRank, connectedList);
if (connectedList.Count > (isNutFound ? 3 : 4))
{
var hand = connectedList.OrderByDescending(x => x).Take(isNutFound ? 4 : 5);
bool isStraight = HandAnalyzerHelpers.IsStraight(hand);
if (isStraight)
{
if (!isNutFound)
{
isNutFound = true;
firstRank = initFirstRank;
nutRank = hand.Max();
continue;
}
else
{
numberOfOpenEndedStraights++;
}
}
}
firstRank--;
}
return(BoardTextureAnalyzerHelpers.CheckEquality(boardTextureItem.SelectedSign.Key, numberOfOpenEndedStraights, boardTextureItem.SelectedNumber));
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || !boardCards.Any())
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(boardCards, playerCards);
if (HandAnalyzerHelpers.HasPair(playerCards, 1) || HandAnalyzerHelpers.IsNoOfKind(boardCards, 3) || !HandAnalyzerHelpers.IsNoOfKind(allCards, 3))
{
return(false);
}
if (boardCards.Count(x => x.Rank == boardCards.Max(b => b.Rank)) == 2 &&
playerCards.Any(x => x.Rank == boardCards.Max(b => b.Rank)))
{
var kicker = playerCards.FirstOrDefault(p => boardCards.All(b => b.Rank != p.Rank));
if (kicker != null)
{
return(HandAnalyzerHelpers.IsDecentKicker(kicker));
}
}
return(false);
}
public bool Analyze(List <DataTypes.Card> playerCards, List <DataTypes.Card> allBoardCards, Street targetStreet)
{
List <DataTypes.Card> boardCards = BoardTextureAnalyzerHelpers.GetCardsAccoringStreet(allBoardCards, targetStreet);
if (playerCards == null || boardCards == null || playerCards.Count() != 2 || boardCards.Count() < 3)
{
return(false);
}
if (playerCards.Any(p => boardCards.Any(b => b.Rank == p.Rank)))
{
return(false);
}
var allCards = HandAnalyzerHelpers.CombineCardLists(playerCards, boardCards);
var rankList = allCards.Select(x => x.Rank).Distinct().ToList();
if (allCards.Any(x => x.Rank == (int)DataTypes.Card.GetCardRank("A")))
{
rankList.Add(1);
}
rankList.Sort();
List <int> currentSequence = new List <int>();
List <int> previousSequence = new List <int>();
for (int i = 0; i < rankList.Count; i++)
{
if (!currentSequence.Any() || (rankList[i] == currentSequence.Last() + 1))
{
currentSequence.Add(rankList[i]);
continue;
}
if (currentSequence.Count >= 1 && currentSequence.Count <= 3)
{
if (!previousSequence.Any())
{
previousSequence = new List <int>(currentSequence);
}
else if ((previousSequence.Max() == currentSequence.Min() - 2) && (previousSequence.Count + currentSequence.Count >= 4))
{
if (HandAnalyzerHelpers.IsStraight(currentSequence) &&
HandAnalyzerHelpers.IsStraight(previousSequence))
{
if (previousSequence.Contains(1))
{
previousSequence[previousSequence.IndexOf(1)] = (int)DataTypes.Card.GetCardRank("A");
}
if (playerCards.All(p => currentSequence.Contains(p.Rank) || previousSequence.Contains(p.Rank)))
{
return(true);
}
}
}
}
previousSequence = new List <int>(currentSequence);
currentSequence.Clear();
currentSequence.Add(rankList[i]);
}
return(false);
}
public void TestPremiumHand(string cards, bool isPremium)
{
var result = HandAnalyzerHelpers.IsPremiumHand(cards);
Assert.That(result, Is.EqualTo(isPremium));
}
