private static List <PlayerstatisticExtended> FilterByPositionCondition(List <PlayerstatisticExtended> playerstatistics, NoteSettingsObject settings)
{
List <PlayerstatisticExtended> fileteredList = new List <PlayerstatisticExtended>();
if (!settings.PositionBB && !settings.PositionButton && !settings.PositionSB && !settings.PositionMiddle && !settings.PositionCutoff && !settings.PositionEarly)
{
return(new List <PlayerstatisticExtended>());
}
if (settings.PositionSB)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.Position == EnumPosition.SB).ToList());
}
if (settings.PositionBB)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.Position == EnumPosition.BB).ToList());
}
if (settings.PositionButton)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.Position == EnumPosition.BTN).ToList());
}
if (settings.PositionCutoff)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.Position == EnumPosition.CO).ToList());
}
if (settings.PositionEarly)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.Position == EnumPosition.EP || x.Playerstatistic.Position == EnumPosition.UTG || x.Playerstatistic.Position == EnumPosition.UTG_1 || x.Playerstatistic.Position == EnumPosition.UTG_2).ToList());
}
if (settings.PositionMiddle)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.Position == EnumPosition.MP || x.Playerstatistic.Position == EnumPosition.MP1 || x.Playerstatistic.Position == EnumPosition.MP2 || x.Playerstatistic.Position == EnumPosition.MP3).ToList());
}
return(fileteredList);
}
private static List <PlayerstatisticExtended> FilterByPositionThreeBetCondition(List <PlayerstatisticExtended> playerStatistics, NoteSettingsObject settings)
{
if (!settings.PositionBB3Bet && !settings.PositionSB3Bet && !settings.PositionButton3Bet &&
!settings.PositionCutoff3Bet && !settings.PositionEarly3Bet && !settings.PositionMiddle3Bet)
{
return(playerStatistics);
}
var fileteredList = new List <PlayerstatisticExtended>();
foreach (var playerStatistic in playerStatistics)
{
var raiser = playerStatistic.HandHistory.PreFlop.FirstOrDefault(x => x.HandActionType == HandActionType.RAISE)?.PlayerName;
if (string.IsNullOrEmpty(raiser))
{
continue;
}
var threeBet = new ConditionalBet();
PlayerStatisticCalculator.Calculate3Bet(threeBet, playerStatistic.HandHistory.PreFlop.ToList(), playerStatistic.Playerstatistic.PlayerName, raiser);
if (!threeBet.Happened)
{
continue;
}
var firstRaiserPosition = Converter.ToPosition(playerStatistic.HandHistory, threeBet.HappenedByPlayer);
var firstRaiserPositionString = Converter.ToPositionString(firstRaiserPosition);
if ((firstRaiserPositionString == "SB" && settings.PositionSB3Bet) ||
(firstRaiserPositionString == "BB" && settings.PositionBB3Bet) ||
(firstRaiserPositionString == "EP" && settings.PositionEarly3Bet) ||
(firstRaiserPositionString == "MP" && settings.PositionMiddle3Bet) ||
(firstRaiserPositionString == "CO" && settings.PositionCutoff3Bet) ||
(firstRaiserPositionString == "BTN" && settings.PositionButton3Bet))
{
fileteredList.Add(playerStatistic);
}
}
return(fileteredList);
}
private static List <PlayerstatisticExtended> FilterByPreflopFacingCondition(List <PlayerstatisticExtended> playerstatistics, NoteSettingsObject settings)
{
List <PlayerstatisticExtended> fileteredList = new List <PlayerstatisticExtended>();
if (!settings.Facing1Limper && !settings.Facing1Raiser && !settings.Facing2PlusLimpers && !settings.Facing2Raisers && !settings.FacingRaisersCallers && !settings.FacingUnopened)
{
return(new List <PlayerstatisticExtended>());
}
if (settings.Facing1Limper && settings.Facing1Raiser && settings.Facing2PlusLimpers && settings.Facing2Raisers && settings.FacingRaisersCallers && settings.FacingUnopened)
{
return(playerstatistics);
}
if (settings.Facing1Limper)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.FacingPreflop == EnumFacingPreflop.Limper).ToList());
}
if (settings.Facing1Raiser)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.FacingPreflop == EnumFacingPreflop.Raiser).ToList());
}
if (settings.Facing2PlusLimpers)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.FacingPreflop == EnumFacingPreflop.MultipleLimpers).ToList());
}
if (settings.Facing2Raisers)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.FacingPreflop == EnumFacingPreflop.ThreeBet).ToList()); //todo check if correct
}
if (settings.FacingRaisersCallers)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.FacingPreflop == EnumFacingPreflop.MultipleCallers).ToList()); //todo check if correct
}
if (settings.FacingUnopened)
{
fileteredList.AddRange(playerstatistics.Where(x => x.Playerstatistic.FacingPreflop == EnumFacingPreflop.Unopened).ToList());
}
return(fileteredList);
}
private static List <PlayerstatisticExtended> FilterByNoOfPlayerCondition(List <PlayerstatisticExtended> playerStatistics, NoteSettingsObject settings)
{
int low = 0, high = 0;
if (settings.PlayersNoCustom)
{
low = settings.PlayersNoMinVal;
high = settings.PlayersNoMaxVal;
}
else
{
if (settings.PlayersNoHeadsUp)
{
low = 2;
}
else if (settings.PlayersNo34)
{
low = 3;
}
else if (settings.PlayersNo56)
{
low = 5;
}
else if (settings.PlayersNoMax)
{
low = 7;
}
if (settings.PlayersNoMax)
{
high = 10;
}
else if (settings.PlayersNo56)
{
high = 6;
}
else if (settings.PlayersNo34)
{
high = 4;
}
else if (settings.PlayersNoHeadsUp)
{
high = 2;
}
}
List <PlayerstatisticExtended> filteredList = new List <PlayerstatisticExtended>();
try
{
filteredList.AddRange(playerStatistics.Where(x => x.HandHistory.GameDescription?.SeatType.MaxPlayers <= high && x.HandHistory.GameDescription?.SeatType.MaxPlayers >= low));
}
catch (Exception ex)
{
LogProvider.Log.Error(CustomModulesNames.PlayerXRay, "FilterByNoOfPlayerCondition method exception", ex);
}
return(filteredList);
}
private static List <PlayerstatisticExtended> FilterByPositionRaiserCondition(List <PlayerstatisticExtended> playerStatistics, NoteSettingsObject settings)
{
// if everything is unchecked return entry list of Playerstatistics
if (!settings.PositionBBRaiser && !settings.PositionButtonRaiser &&
!settings.PositionCutoffRaiser && !settings.PositionEarlyRaiser &&
!settings.PositionMiddleRaiser && !settings.PositionSBRaiser)
{
return(playerStatistics);
}
var fileteredList = new List <PlayerstatisticExtended>();
foreach (var playerStatistic in playerStatistics)
{
var facedHandActions = new List <HandAction>();
foreach (var hA in playerStatistic.HandHistory.HandActions
.Where(hA => hA.HandActionType != HandActionType.SMALL_BLIND && hA.HandActionType != HandActionType.BIG_BLIND &&
hA.HandActionType != HandActionType.ANTE && hA.HandActionType != HandActionType.POSTS))
{
if (hA.PlayerName != playerStatistic.Playerstatistic.PlayerName)
{
facedHandActions.Add(hA);
}
else
{
break;
}
}
var handAction = facedHandActions.FirstOrDefault(x => x.HandActionType == HandActionType.RAISE);
var firstRaiserPositionString = string.Empty;
if (handAction != null)
{
var firstRaiserPosition = Converter.ToPosition(playerStatistic.HandHistory, handAction.PlayerName);
firstRaiserPositionString = Converter.ToPositionString(firstRaiserPosition);
}
if (string.IsNullOrEmpty(firstRaiserPositionString))
{
return(fileteredList);
}
if ((firstRaiserPositionString == "SB" && settings.PositionSBRaiser) ||
(firstRaiserPositionString == "BB" && settings.PositionBBRaiser) ||
(firstRaiserPositionString == "EP" && settings.PositionEarlyRaiser) ||
(firstRaiserPositionString == "MP" && settings.PositionMiddleRaiser) ||
(firstRaiserPositionString == "CO" && settings.PositionCutoffRaiser) ||
(firstRaiserPositionString == "BTN" && settings.PositionButtonRaiser))
{
fileteredList.Add(playerStatistic);
}
}
return(fileteredList);
}
private static List <PlayerstatisticExtended> FilterByStakeCondition(List <PlayerstatisticExtended> playerStatistics, NoteSettingsObject settings)
{
List <PlayerstatisticExtended> fileteredList = playerStatistics;
if (settings.ExcludedStakes.Count == 0)
{
return(playerStatistics);
}
foreach (Stake stake in StaticStorage.Stakes)
{
//ignoring any excluded stake
if (settings.ExcludedStakes.Count(p => p.Name == stake.Name) > 0)
{
continue;
}
fileteredList = fileteredList.Where(x => x.Playerstatistic.PokergametypeId == stake.ID &&
x.Playerstatistic.BigBlind == stake.StakeValue).ToList();
}
return(fileteredList);
}
private static List <PlayerstatisticExtended> FilterByMiscConditions(List <PlayerstatisticExtended> selectedPlayerStatistics, NoteSettingsObject settings)
{
if (settings.Cash && settings.Tournament)
{
return(selectedPlayerStatistics);
}
return(selectedPlayerStatistics
.Where(x => settings.Tournament && x.Playerstatistic.IsTourney ||
settings.Cash && !x.Playerstatistic.IsTourney)
.ToList());
}
private static List <PlayerstatisticExtended> FilterByHoleCardCondition(List <PlayerstatisticExtended> playerStatistics, NoteSettingsObject settings)
{
// list if excluded hole cards
if (settings.ExcludedCardsList.Count == 0)
{
return(playerStatistics);
}
List <long> list = new List <long>();
foreach (string excludedCard in settings.ExcludedCardsList)
{
list.Add(HoleCardsHelper.GetHoleCardValue(excludedCard));
}
//list of the selected hole cards
List <long> selectedCards = new List <long>();
for (int i = 1; i < 170; i++)
{
if (!list.Contains(i))
{
selectedCards.Add(i);
}
}
return(playerStatistics.Where(x => x.Playerstatistic.Cards.Length > 0 &&
selectedCards.Contains(HoleCardsHelper.ConverterCardsToSuitedUnsuited(x.Playerstatistic.Cards))).ToList());
}
private static List <PlayerstatisticExtended> FilterByPreflopActionCondition(List <PlayerstatisticExtended> playerStatistics, NoteSettingsObject settings)
{
var fileteredList = new List <PlayerstatisticExtended>();
var preflopObligatoryActions = GetObligatoryActions(settings.PreflopActions);
foreach (var playerstatistic in playerStatistics)
{
var preflopActions = playerstatistic.HandHistory.PreFlop.ToList();
var playerPreFlopActions = preflopActions
.Where(x => x.PlayerName == playerstatistic.Playerstatistic.PlayerName &&
x.HandActionType != HandActionType.SMALL_BLIND && x.HandActionType != HandActionType.BIG_BLIND).ToList();
if (CompareHandActionsWithObligatoryHandActions(playerPreFlopActions, preflopActions, preflopObligatoryActions))
{
fileteredList.Add(playerstatistic);
}
}
return(fileteredList);
}
private static List <PlayerstatisticExtended> FilterByFlopActionCondition(List <PlayerstatisticExtended> playerStatistics, NoteSettingsObject settings)
{
var fileteredList = new List <PlayerstatisticExtended>();
var flopObligatoryActions = GetObligatoryActions(settings.FlopActions);
foreach (var playerstatistic in playerStatistics)
{
var flopActions = playerstatistic.HandHistory.Flop.ToList();
var playerFlopActions = flopActions.Where(x => x.PlayerName == playerstatistic.Playerstatistic.PlayerName).ToList();
if (CompareHandActionsWithObligatoryHandActions(playerFlopActions, flopActions, flopObligatoryActions))
{
fileteredList.Add(playerstatistic);
}
}
return(fileteredList);
}
private static List <PlayerstatisticExtended> FilterByRiverTextureCondition(List <PlayerstatisticExtended> playerStatistics, NoteSettingsObject settings)
{
if (!settings.RiverTextureSettings.IsFlushCardFilter && !settings.RiverTextureSettings.IsPossibleStraightsFilter && !settings.RiverTextureSettings.IsHighcardFilter && !settings.RiverTextureSettings.IsCardTextureFilter && !settings.RiverTextureSettings.IsPairedFilter)
{
return(playerStatistics);
}
List <PlayerstatisticExtended> fileteredList = new List <PlayerstatisticExtended>();
foreach (var playerstatistic in playerStatistics)
{
//filters for river flush
if (settings.RiverTextureSettings.IsFlushCardFilter)
{
//filter for no possible flush
if (settings.RiverTextureSettings.FlushCard == RiverFlushCardsEnum.NoFlush && !new NoPossibleFlushTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.River))
{
continue;
}
//filter for three of one suit
if (settings.RiverTextureSettings.FlushCard == RiverFlushCardsEnum.ThreeCardsOneSuit && !new ThreeOfOneSuitFlushTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.River))
{
continue;
}
//filter for four of one suit
if (settings.RiverTextureSettings.FlushCard == RiverFlushCardsEnum.FourCardsOneSuit && !new FourOfOneSuitFlushTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.River))
{
continue;
}
//filter for five of one suit
if (settings.RiverTextureSettings.FlushCard == RiverFlushCardsEnum.FiveCardsOneSuit && !new FiveOfOneSuitFlushTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.River))
{
continue;
}
}
//filter for possible straights and according < > or ==
if (settings.RiverTextureSettings.IsPossibleStraightsFilter)
{
if (!BoardTextureAnalyzerHelpers.CheckEquality(settings.RiverTextureSettings.PossibleStraightsCompare, new PossibleStraightTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.River), settings.RiverTextureSettings.PossibleStraights))
{
continue;
}
}
//filter for the highest card
if (settings.RiverTextureSettings.IsHighcardFilter)
{
if (BoardTextureAnalyzerHelpers.HighestBoardCardRank(playerstatistic.Playerstatistic.Board, Street.River) != DataTypes.Card.GetCardRank(settings.RiverTextureSettings.HighestCard))
{
continue;
}
}
//filter for exact river texture
if (settings.RiverTextureSettings.IsCardTextureFilter)
{
if (!BoardTextureAnalyzerHelpers.BoardContainsExactTextureCards(playerstatistic.Playerstatistic.Board, settings.RiverTextureSettings.SelectedCardTextureList, Street.River))
{
continue;
}
}
//filter for river is Paired
if (settings.RiverTextureSettings.IsPairedFilter)
{
if (!BoardTextureAnalyzerHelpers.BoardContainsAPair(playerstatistic.Playerstatistic.Board, Street.River))
{
continue;
}
}
fileteredList.Add(playerstatistic);
}
return(fileteredList);
}
private static List <PlayerstatisticExtended> FilterByTurnTextureCondition(List <PlayerstatisticExtended> playerStatistics, NoteSettingsObject settings)
{
if (!settings.TurnTextureSettings.IsFlushCardFilter && !settings.TurnTextureSettings.IsOpenEndedStraightDrawsFilter && !settings.TurnTextureSettings.IsPossibleStraightsFilter && !settings.TurnTextureSettings.IsGutshotsFilter && !settings.TurnTextureSettings.IsHighcardFilter && !settings.TurnTextureSettings.IsCardTextureFilter && !settings.TurnTextureSettings.IsPairedFilter)
{
return(playerStatistics);
}
List <PlayerstatisticExtended> fileteredList = new List <PlayerstatisticExtended>();
foreach (var playerstatistic in playerStatistics)
{
//filters for turn flush
if (settings.TurnTextureSettings.IsFlushCardFilter)
{
//filter for rainbow flush
if (settings.TurnTextureSettings.FlushCard == TurnFlushCardsEnum.Rainbow && !new NoPossibleFlushTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.Turn))
{
continue;
}
//filter for two of two suits
if (settings.TurnTextureSettings.FlushCard == TurnFlushCardsEnum.TwoOfTwoSuits && !new TwoOfTwoSuitFlushTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.Turn))
{
continue;
}
//filter for two of one suit
if (settings.TurnTextureSettings.FlushCard == TurnFlushCardsEnum.TwoOfOneSuit && !new TwoOfOneSuitFlushTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.Turn))
{
continue;
}
//filter for three of one suit
if (settings.TurnTextureSettings.FlushCard == TurnFlushCardsEnum.ThreeOfOneSuit && !new ThreeOfOneSuitFlushTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.Turn))
{
continue;
}
//filter for four of one suit
if (settings.TurnTextureSettings.FlushCard == TurnFlushCardsEnum.FourOfOneSuit && !new FourOfOneSuitFlushTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.Turn))
{
continue;
}
}
//filter for open-ended straights
//if number of open ended straigths is not equal to the number we need, then we skip such playerstatistic
if (settings.TurnTextureSettings.IsOpenEndedStraightDrawsFilter)
{
if (new OpenEndedStraightTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.Turn) != settings.TurnTextureSettings.OpenEndedStraightDraws)
{
continue;
}
}
//filter for possible straights and according < > or ==
if (settings.TurnTextureSettings.IsPossibleStraightsFilter)
{
if (!BoardTextureAnalyzerHelpers.CheckEquality(settings.TurnTextureSettings.PossibleStraightsCompare, new PossibleStraightTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.Turn), settings.TurnTextureSettings.PossibleStraights))
{
continue;
}
}
//filter for gutshot straights
if (settings.TurnTextureSettings.IsGutshotsFilter)
{
if (new GutShotBeatNutsTextureAnalyzer().Analyze(playerstatistic.Playerstatistic.Board, Street.Turn) != settings.TurnTextureSettings.Gutshots)
{
continue;
}
}
//filter for the highest card
if (settings.TurnTextureSettings.IsHighcardFilter)
{
if (BoardTextureAnalyzerHelpers.HighestBoardCardRank(playerstatistic.Playerstatistic.Board, Street.Turn) != DataTypes.Card.GetCardRank(settings.TurnTextureSettings.HighestCard))
{
continue;
}
}
//filter for exact turn texture
if (settings.TurnTextureSettings.IsCardTextureFilter)
{
if (!BoardTextureAnalyzerHelpers.BoardContainsExactTextureCards(playerstatistic.Playerstatistic.Board, settings.TurnTextureSettings.SelectedCardTextureList, Street.Turn))
{
continue;
}
}
//filter for Turn is Paired
if (settings.TurnTextureSettings.IsPairedFilter)
{
if (!BoardTextureAnalyzerHelpers.BoardContainsAPair(playerstatistic.Playerstatistic.Board, Street.Turn))
{
continue;
}
}
fileteredList.Add(playerstatistic);
}
return(fileteredList);
}
