public void TestOmahaOnePairAnalyzer()
{
var analyzer = new OmahaOnePairAnalyzer();
var item11 = CreateOnePairHandGridItem(new Tuple <string, string>("", ""));
var item12 = CreateOnePairHandGridItem(new Tuple <string, string>("", "4"));
var cards1 = CardGroup.Parse("4c8cKcAc");
var item21 = CreateOnePairHandGridItem(new Tuple <string, string>("", ""));
var item22 = CreateOnePairHandGridItem(new Tuple <string, string>("", "K"));
var item23 = CreateOnePairHandGridItem(new Tuple <string, string>("", "4"));
var cards2 = CardGroup.Parse("KcKd4c5c");
var item31 = CreateOnePairHandGridItem(new Tuple <string, string>("", ""));
var item32 = CreateOnePairHandGridItem(new Tuple <string, string>("", "5"));
var cards3 = CardGroup.Parse("5c5d9c9d");
var cards4 = CardGroup.Parse("5d5c5h2c");
var cards5 = CardGroup.Parse("5c5d5h5s");
Assert.That(analyzer.Analyze(cards1, item11), Is.False);
Assert.That(analyzer.Analyze(cards1, item12), Is.False);
Assert.That(analyzer.Analyze(cards2, item21), Is.True);
Assert.That(analyzer.Analyze(cards2, item22), Is.True);
Assert.That(analyzer.Analyze(cards2, item23), Is.False);
Assert.That(analyzer.Analyze(cards3, item31), Is.False);
Assert.That(analyzer.Analyze(cards3, item32), Is.False);
Assert.That(analyzer.Analyze(cards4, item31), Is.False);
Assert.That(analyzer.Analyze(cards4, item32), Is.False);
Assert.That(analyzer.Analyze(cards5, item31), Is.False);
Assert.That(analyzer.Analyze(cards5, item32), Is.False);
}
public void SetUp()
{
_handHistory = new HandHistory()
{
ComumnityCards =
BoardCards.ForFlop(new Card(5), new Card(14), new Card(40)),
DateOfHandUtc = new DateTime(2012, 3, 20, 12, 30, 44),
DealerButtonPosition = 5,
FullHandHistoryText = "some hand text",
GameDescription =
new GameDescriptor(PokerFormat.CashGame,
SiteName.Values.PartyPoker,
GameType.NoLimitHoldem,
Limit.FromSmallBlindBigBlind(10, 20, Currency.USD),
TableType.FromTableTypeDescriptions(TableTypeDescription.Regular),
SeatType.FromMaxPlayers(6)),
HandActions = new List <HandAction>()
{
new HandAction("Player1", HandActionType.POSTS, 0.25m, Street.Preflop)
},
HandId = 141234124,
NumPlayersSeated = 2,
Players = new PlayerList()
{
new Player("Player1", 1000, 1),
new Player("Player2", 300, 5),
},
TableName = "Test Table",
};
_handHistory.Players[0].HoleCards = new HoleCards(CardGroup.Parse("Ac Ad"));
_handHistory.Players[1].HoleCards = new HoleCards(CardGroup.Parse("Kh Qs"));
BsonSerializer.RegisterSerializationProvider(new TestSerializationProvider());
}
public void TestOmahaHoleCardStructureLowCardsAnalyzer()
{
var analyzer = new OmahaHoleCardStructureLowCardsAnalyzer();
var item = new HoleCardStructureHandGridItem()
{
SelectedNumber = 1
};
var item2 = new HoleCardStructureHandGridItem()
{
SelectedNumber = 2
};
var cards = CardGroup.Parse("Ac6d6h6s");
var cards2 = CardGroup.Parse("Ac2c4d3s");
var cards3 = CardGroup.Parse("KdAsAd2s");
var cards4 = CardGroup.Parse("KdTs2s5s");
Assert.That(analyzer.Analyze(cards, item), Is.False);
Assert.That(analyzer.Analyze(cards, item2), Is.False);
Assert.That(analyzer.Analyze(cards2, item), Is.False);
Assert.That(analyzer.Analyze(cards2, item2), Is.False);
Assert.That(analyzer.Analyze(cards3, item), Is.True);
Assert.That(analyzer.Analyze(cards3, item2), Is.False);
Assert.That(analyzer.Analyze(cards4, item), Is.False);
Assert.That(analyzer.Analyze(cards4, item2), Is.True);
}
/// <summary>
/// Checks if specific omaha hole cards pass the filter
/// </summary>
/// <param name="cards">omaha hole cards</param>
/// <param name="collection">collection of items that contains filter description</param>
/// <returns></returns>
public static bool CheckOmahaHoleCards(string cards, IEnumerable <OmahaHandGridItem> collection)
{
var cardsList = CardGroup.Parse(cards);
var analyzers = OmahaHoleCardsAnalyzer.GetDefaultOmahaHoleCardsAnalyzers();
return(collection.All(item => analyzers.First(a => a.GetRank() == item.HoleCards).Analyze(cardsList, item)));
}
public void OmahaEquityCalcTest(string boardCards, bool isHiLo, float[] equity)
{
BoardCards board = BoardCards.FromCards(boardCards);
var cards = GetHoleCards().Select(x => CardGroup.Parse(x).Select(c => c.ToString()).ToArray()).ToArray();
OmahaEquityCalculatorMain calc = new OmahaEquityCalculatorMain(true, isHiLo);
var result = calc.Equity(board.Select(x => x.ToString()).ToArray(), cards, new string[] { }, 0);
var i = 0;
}
public HoleCards Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
if (context.Reader.CurrentBsonType != MongoDB.Bson.BsonType.Null)
{
string cards = context.Reader.ReadString();
return(new HoleCards(CardGroup.Parse(cards)));
}
else
{
context.Reader.SkipValue();
return(null);
}
}
public void TestOmahaNoPairAnalyzer()
{
var analyzer = new OmahaNoPairAnalyzer();
var item = new OmahaHandGridItem();
var cards = CardGroup.Parse("4c8cKcAc");
var cards2 = CardGroup.Parse("KcKd4c5c");
var cards3 = CardGroup.Parse("5c5d9c9d");
var cards4 = CardGroup.Parse("6d6c6h2c");
var cards5 = CardGroup.Parse("6c6d6h6s");
Assert.That(analyzer.Analyze(cards, item), Is.True);
Assert.That(analyzer.Analyze(cards2, item), Is.False);
Assert.That(analyzer.Analyze(cards3, item), Is.False);
Assert.That(analyzer.Analyze(cards4, item), Is.False);
Assert.That(analyzer.Analyze(cards5, item), Is.False);
}
public void TestOmahaFourCardWrapAnalyzer()
{
var analyzer = new OmahaFourCardWrapAnalyzer();
var cards0 = CardGroup.Parse("2s3s4sAd");
var cards1 = CardGroup.Parse("2s4s5s6d");
var cards2 = CardGroup.Parse("As2s3s6d");
var cards3 = CardGroup.Parse("Ad5s6s7d");
var cards4 = CardGroup.Parse("Ad2d7s8s");
var item0 = CreateWrapsAndRundownsHandGridItem(new Tuple <string, int>("", 0));
var item1 = CreateWrapsAndRundownsHandGridItem(new Tuple <string, int>("", 1));
var item2 = CreateWrapsAndRundownsHandGridItem(new Tuple <string, int>("", 2));
var item3 = CreateWrapsAndRundownsHandGridItem(new Tuple <string, int>("", 3));
var item4 = CreateWrapsAndRundownsHandGridItem(new Tuple <string, int>("", 4));
Assert.That(analyzer.Analyze(cards0, item0), Is.True);
Assert.That(analyzer.Analyze(cards0, item0), Is.True);
Assert.That(analyzer.Analyze(cards0, item1), Is.False);
Assert.That(analyzer.Analyze(cards0, item2), Is.False);
Assert.That(analyzer.Analyze(cards0, item3), Is.False);
Assert.That(analyzer.Analyze(cards0, item4), Is.False);
Assert.That(analyzer.Analyze(cards1, item0), Is.False);
Assert.That(analyzer.Analyze(cards1, item1), Is.True);
Assert.That(analyzer.Analyze(cards1, item2), Is.False);
Assert.That(analyzer.Analyze(cards1, item3), Is.False);
Assert.That(analyzer.Analyze(cards1, item4), Is.False);
Assert.That(analyzer.Analyze(cards2, item0), Is.False);
Assert.That(analyzer.Analyze(cards2, item1), Is.False);
Assert.That(analyzer.Analyze(cards2, item2), Is.True);
Assert.That(analyzer.Analyze(cards2, item3), Is.False);
Assert.That(analyzer.Analyze(cards2, item4), Is.False);
Assert.That(analyzer.Analyze(cards3, item0), Is.False);
Assert.That(analyzer.Analyze(cards3, item1), Is.False);
Assert.That(analyzer.Analyze(cards3, item2), Is.False);
Assert.That(analyzer.Analyze(cards3, item3), Is.True);
Assert.That(analyzer.Analyze(cards3, item4), Is.False);
Assert.That(analyzer.Analyze(cards4, item0), Is.False);
Assert.That(analyzer.Analyze(cards4, item1), Is.False);
Assert.That(analyzer.Analyze(cards4, item2), Is.False);
Assert.That(analyzer.Analyze(cards4, item3), Is.False);
Assert.That(analyzer.Analyze(cards4, item4), Is.True);
}
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 void TestOmahaDoubleSuitedAnalyzer()
{
var analyzer = new OmahaDoubleSuitedAnalyzer();
var item = new OmahaHandGridItem();
var cards = CardGroup.Parse("6c6d6h6s");
var cards2 = CardGroup.Parse("Ac2c4d4s");
var cards3 = CardGroup.Parse("2c3c3d4c");
var cards4 = CardGroup.Parse("Ac2c3d4d");
var cards5 = CardGroup.Parse("2c3c4c5d");
var cards6 = CardGroup.Parse("2c3c4sAd");
Assert.That(analyzer.Analyze(cards, item), Is.False);
Assert.That(analyzer.Analyze(cards2, item), Is.False);
Assert.That(analyzer.Analyze(cards3, item), Is.False);
Assert.That(analyzer.Analyze(cards4, item), Is.True);
Assert.That(analyzer.Analyze(cards5, item), Is.False);
Assert.That(analyzer.Analyze(cards6, item), Is.False);
}
private HoleCards ParseHoleCards(string handText, string playerName)
{
try
{
string regexString = GetHoleCardsRegex(playerName);
var regex = Regex.Match(handText, regexString);
if (regex.Success)
{
return(HoleCards.FromCards(playerName, CardGroup.Parse(regex.Value)));
}
else
{
return(HoleCards.NoHolecards(playerName));
}
}
catch (Exception ex)
{
throw new CardException(handText, "ParseHoleCards: Exception " + ex.Message);
}
}
private string ConvertCards(string cards)
{
var cardGroup = CardGroup.Parse(cards);
return(string.Join(" ", cardGroup.Select(card => card.ToString().ToUpper().Reverse().Replace("T", "10"))));
}
public IAnalyzer Analyze(IEnumerable <HandHistories.Objects.Cards.Card> playerCards, BoardCards boardCards)
{
try
{
IAnalyzer result = null;
var highestHand = CardHelper.FindBestHand(string.Join("", playerCards.Select(c => c.CardStringValue)), boardCards.ToString());
var analyzers = ReferenceEquals(highestHand, null) ? _combinations : _combinations.Where(x => x.IsValidAnalyzer(highestHand)).ToArray();
if (playerCards.Count() > 2 && !string.IsNullOrEmpty(highestHand.PocketCards))
{
result = analyzers.FirstOrDefault(combination => combination.Analyze(CardGroup.Parse(highestHand.PocketCards), boardCards)) ?? new StubAnalyzer();
}
else
{
result = analyzers.FirstOrDefault(combination => combination.Analyze(playerCards, boardCards)) ?? new StubAnalyzer();
}
return(result);
}
catch (Exception ex)
{
LogProvider.Log.Error(this, String.Format("Hand Analyzer Error occurred: Player cards = {0}; Board Cards = {1}", string.Join("", playerCards.Select(c => c.CardStringValue)), boardCards.ToString()), ex);
}
return(new StubAnalyzer());
}
