public bool ShouldAGridFoldToBet(RangeGrid grid)
{
var grade = TestGridAgainstBoard(grid).Item1.Grade();
var hit = HitTurn(grid);
return(hit == GridHitNewRoundResultEnum.None && grade <= RankHandGradeEnum.OnePair);
}
public bool ShouldAGridFoldToBet(RangeGrid grid)
{
var outcome = TestGridAgainstBoard(grid).Item1;
return(outcome == FoursomeOutcomeEnum.FoursomeWeakKicker ||
outcome == FoursomeOutcomeEnum.FoursomeNoneKicker);
}
public SuitedStatus <BoardRangeGridStatusEnum> TestSuitedGrid(RangeGrid grid)
{
if (grid.Category != GridCategoryEnum.Suited)
{
throw new InvalidOperationException($"{grid.Category}");
}
var result = new SuitedStatus <BoardRangeGridStatusEnum>();
var suits = new SuitEnum[] { SuitEnum.Heart, SuitEnum.Spade, SuitEnum.Diamond, SuitEnum.Club };
foreach (var suit in suits)
{
if (!(grid.Card1AvaliableSuits.Contains(suit) && grid.Card2AvaliableSuits.Contains(suit)))
{
switch (suit)
{
case SuitEnum.Heart:
result.HeartStatus = BoardRangeGridStatusEnum.Unavailable;
break;
case SuitEnum.Spade:
result.SpadeStatus = BoardRangeGridStatusEnum.Unavailable;
break;
case SuitEnum.Diamond:
result.DiamondStatus = BoardRangeGridStatusEnum.Unavailable;
break;
case SuitEnum.Club:
result.ClubStatus = BoardRangeGridStatusEnum.Unavailable;
break;
}
continue;
}
var hole1 = new Card(suit, grid.HighRank);
var hole2 = new Card(suit, grid.LowRank);
var outcome = TestGridAgainstBoard(hole1, hole2).Item1;
switch (suit)
{
case SuitEnum.Heart:
result.HeartStatus = TranslateOutcomeToGridStatus(outcome);
break;
case SuitEnum.Spade:
result.SpadeStatus = TranslateOutcomeToGridStatus(outcome);
break;
case SuitEnum.Diamond:
result.DiamondStatus = TranslateOutcomeToGridStatus(outcome);
break;
case SuitEnum.Club:
result.ClubStatus = TranslateOutcomeToGridStatus(outcome);
break;
}
}
return(result);
}
public GridHitNewRoundResultEnum HitTurn(RangeGrid grid)
{
RankHandGradeEnum flopGrade;
int flopInvolved;
switch (FlopBoard.RankTexture)
{
case FlopBoardRankTextureEnum.LowPair:
var lowPairTuple = new Flop.FlopBoardRankTextures.LowPairRankTexture(FlopBoard).TestGridAgainstBoard(grid);
flopGrade = lowPairTuple.Item1.Grade();
flopInvolved = lowPairTuple.Item2;
break;
case FlopBoardRankTextureEnum.ThreeSome:
var threesomeTuple = new Flop.FlopBoardRankTextures.ThreeSomeRankTexture(FlopBoard).TestGridAgainstBoard(grid);
flopGrade = threesomeTuple.Item1.Grade();
flopInvolved = threesomeTuple.Item2;
break;
default:
throw new InvalidOperationException($"Impossible to have {FlopBoard.RankTexture}");
}
var turnTuple = TestGridAgainstBoard(grid);
var turnOutcomeGrade = turnTuple.Item1.Grade();
var turnInvolved = turnTuple.Item2;
if (turnOutcomeGrade > flopGrade)
{
return((turnInvolved > flopInvolved) ? GridHitNewRoundResultEnum.Promoted : GridHitNewRoundResultEnum.Enhanced);
}
return(GridHitNewRoundResultEnum.None);
}
public bool ShouldAGridFoldToBoardByRank(RangeGrid grid, TurnBoard turnBoard)
{
switch (turnBoard.RankTexture)
{
case TurnBoardRankTextureEnum.Foursome:
return(new FoursomeRankTexture(turnBoard).ShouldAGridFoldToBet(grid));
case TurnBoardRankTextureEnum.HighTri:
return(new HighTriRankTexture(turnBoard).ShouldAGridFoldToBet(grid));
case TurnBoardRankTextureEnum.LowTri:
return(new LowTriRankTexture(turnBoard).ShouldAGridFoldToBet(grid));
case TurnBoardRankTextureEnum.TwoPairs:
return(new TwoPairsRankTexture(turnBoard).ShouldAGridFoldToBet(grid));
case TurnBoardRankTextureEnum.HighPair:
return(new HighPairRankTexture(turnBoard).ShouldAGridFoldToBet(grid));
case TurnBoardRankTextureEnum.MiddlePair:
return(new MiddlePairRankTexture(turnBoard).ShouldAGridFoldToBet(grid));
case TurnBoardRankTextureEnum.LowPair:
return(new LowPairRankTexture(turnBoard).ShouldAGridFoldToBet(grid));
case TurnBoardRankTextureEnum.Singles:
return(new SinglesRankTexture(turnBoard).ShouldAGridFoldToBet(grid));
}
throw new NotImplementedException();
}
public BoardRangeGridStatusEnum TestGridAgainstFlopBoard(RangeGrid grid)
{
var outcome = TestGridAgainstBoard(grid).Item1;
Logger.Instance.Log($"Testing {grid.ToString()} against LowPair flop, outcome is {outcome}");
switch (outcome)
{
case LowPairOutcomeEnum.FourSome:
case LowPairOutcomeEnum.HighFullHouse:
return(BoardRangeGridStatusEnum.Nuts);
case LowPairOutcomeEnum.LowFullHouse:
case LowPairOutcomeEnum.ThreeSomeTopKicker:
case LowPairOutcomeEnum.ThreeSomeGoodKicker:
return(BoardRangeGridStatusEnum.Elite);
case LowPairOutcomeEnum.ThreeSomeWeakKicker:
case LowPairOutcomeEnum.OverTwoPairs:
return(BoardRangeGridStatusEnum.Good);
case LowPairOutcomeEnum.OnePairTopKicker:
case LowPairOutcomeEnum.OnePairGoodKicker:
case LowPairOutcomeEnum.OnePairWeakKicker:
return(ShouldRankDrawFold(grid) ? BoardRangeGridStatusEnum.Trash : BoardRangeGridStatusEnum.Marginal);
default:
return(BoardRangeGridStatusEnum.Marginal);
}
}
private GridStatusInBoardRange TestGrid(FlopBoard flopBoard, RangeGrid grid)
{
var result = new GridStatusInBoardRange(grid.Category);
var rankTester = GetGridRankTester(flopBoard);
var rankResult = rankTester.Invoke(grid);
result.RankWiseStatus = rankResult;
switch (result.Category)
{
case GridCategoryEnum.Suited:
result.SuitedStatus = GetSuitedTester(flopBoard).Invoke(grid);
break;
case GridCategoryEnum.Paired:
result.PairedStatus = GetPairedTester(flopBoard).Invoke(grid);
break;
case GridCategoryEnum.Offsuit:
result.OffsuitStatus = GetOffsuitTester(flopBoard).Invoke(grid);
break;
}
return(result);
}
public BoardRangeGridStatusEnum TestGridAgainstFlopBoard(RangeGrid grid)
{
var outcome = TestGridAgainstBoard(grid).Item1;
BoardRangeGridStatusEnum result;
switch (outcome)
{
case ThreesomeOutcomeEnum.FourSome:
result = BoardRangeGridStatusEnum.Nuts;
break;
case ThreesomeOutcomeEnum.TopFullHouse:
case ThreesomeOutcomeEnum.GoodFullHouse:
result = BoardRangeGridStatusEnum.Elite;
break;
case ThreesomeOutcomeEnum.WeakFullHouse:
result = BoardRangeGridStatusEnum.Good;
break;
case ThreesomeOutcomeEnum.ThreeSomeGoodKicker:
case ThreesomeOutcomeEnum.ThreeSomeWeakKicker:
result = BoardRangeGridStatusEnum.Trash;
break;
default:
result = BoardRangeGridStatusEnum.Marginal;
break;
}
Logger.Instance.Log($"{grid.ToString()} tested on Threesome flop, outcome:{outcome}|result:{result}");
return(result);
}
private Tuple <HighTriLowPairOutcomeEnum, int> TestGridAgainstBoard(RangeGrid grid)
{
/*
* HighFoursome,
* LowFoursome,
* TopPairFullHouse,
* GoodOverPairFullHouse,
* WeakOverPairFullHouse,
* MiddleFullHouse,*/
if (grid.HighRank == TriCard1.Rank || grid.LowRank == TriCard1.Rank)
{
return(new Tuple <HighTriLowPairOutcomeEnum, int>(HighTriLowPairOutcomeEnum.HighFoursome, 1));
}
if (grid.Category == GridCategoryEnum.Paired)
{
if (grid.HighRank == PairCard1.Rank)
{
return(new Tuple <HighTriLowPairOutcomeEnum, int>(HighTriLowPairOutcomeEnum.LowFoursome, 2));
}
if (grid.HighRank > PairCard1.Rank)
{
if (grid.HighRank == RankEnum.Ace)
{
return(new Tuple <HighTriLowPairOutcomeEnum, int>(HighTriLowPairOutcomeEnum.TopPairFullHouse, 2));
}
if (grid.HighRank > RankEnum.Ten)
{
return(new Tuple <HighTriLowPairOutcomeEnum, int>(HighTriLowPairOutcomeEnum.GoodOverPairFullHouse, 2));
}
return(new Tuple <HighTriLowPairOutcomeEnum, int>(HighTriLowPairOutcomeEnum.WeakOverPairFullHouse, 2));
}
}
return(new Tuple <HighTriLowPairOutcomeEnum, int>(HighTriLowPairOutcomeEnum.FullHouse, 0));
}
public GridHitNewRoundResultEnum HitRiver(RangeGrid grid)
{
RankHandGradeEnum turnGrade;
int turnInvolved;
switch (TurnBoard.RankTexture)
{
case TurnBoardRankTextureEnum.HighPair:
var highPairTuple = new Turn.TurnBoardRankTextures.HighPairRankTexture(TurnBoard).TestGridAgainstBoard(grid);
turnGrade = highPairTuple.Item1.Grade();
turnInvolved = highPairTuple.Item2;
break;
case TurnBoardRankTextureEnum.Singles:
var singlesTuple = new Turn.TurnBoardRankTextures.SinglesRankTexture(TurnBoard).TestGridAgainstBoard(grid);
turnGrade = singlesTuple.Item1.Grade();
turnInvolved = singlesTuple.Item2;
break;
default:
throw new InvalidOperationException($"Impossible to have {TurnBoard.RankTexture}");
}
var riverTuple = TestGridAgainstBoard(grid);
var riverOutcomeGrade = riverTuple.Item1.Grade();
var riverInvolved = riverTuple.Item2;
if (riverOutcomeGrade > turnGrade)
{
return((riverInvolved > turnInvolved) ? GridHitNewRoundResultEnum.Promoted : GridHitNewRoundResultEnum.Enhanced);
}
return(GridHitNewRoundResultEnum.None);
}
public bool ShouldAGridFoldToBet(RangeGrid grid)
{
var outcome = TestGridAgainstBoard(grid).Item1;
return(outcome == ThirdPairOutcomeEnum.GoodKicker ||
outcome == ThirdPairOutcomeEnum.WeakKicker ||
outcome == ThirdPairOutcomeEnum.NoneKicker);
}
public T Get(RangeGrid grid)
{
if (_dict.ContainsKey(grid.ToString()))
{
return(_dict[grid.ToString()]);
}
return(default(T));
}
public Tuple <TwoPairsOutcomeEnum, int> TestGridAgainstBoard(RangeGrid grid)
{/*
* HighFoursome,
* LowFoursome,
* HighFullHouse,
* LowFullHouse,
* OverTwoPairs,
* HighBetweenTwoPairs,
* TopKicker,
* OverGoodKicker,
* OverWeakKicker,
* NoneKicker*/
if (grid.Category == GridCategoryEnum.Paired)
{
if (grid.HighRank == HighPairCard1.Rank)
{
return(new Tuple <TwoPairsOutcomeEnum, int>(TwoPairsOutcomeEnum.HighFoursome, 2));
}
if (grid.HighRank == LowPairCard1.Rank)
{
return(new Tuple <TwoPairsOutcomeEnum, int>(TwoPairsOutcomeEnum.LowFoursome, 2));
}
}
if (grid.HighRank == HighPairCard1.Rank || grid.LowRank == HighPairCard1.Rank)
{
return(new Tuple <TwoPairsOutcomeEnum, int>(TwoPairsOutcomeEnum.HighFullHouse, 1));
}
if (grid.HighRank == LowPairCard1.Rank || grid.LowRank == LowPairCard2.Rank)
{
return(new Tuple <TwoPairsOutcomeEnum, int>(TwoPairsOutcomeEnum.LowFullHouse, 1));
}
if (grid.Category == GridCategoryEnum.Paired)
{
if (grid.HighRank > HighPairCard1.Rank)
{
return(new Tuple <TwoPairsOutcomeEnum, int>(TwoPairsOutcomeEnum.OverTwoPairs, 2));
}
if (grid.HighRank > LowPairCard1.Rank)
{
return(new Tuple <TwoPairsOutcomeEnum, int>(TwoPairsOutcomeEnum.HighBetweenTwoPairs, 2));
}
}
if (grid.HighRank == RankEnum.Ace)
{
return(new Tuple <TwoPairsOutcomeEnum, int>(TwoPairsOutcomeEnum.TopKicker, 0));
}
if (grid.HighRank > RankEnum.Ten)
{
return(new Tuple <TwoPairsOutcomeEnum, int>(TwoPairsOutcomeEnum.GoodKicker, 0));
}
return(new Tuple <TwoPairsOutcomeEnum, int>(TwoPairsOutcomeEnum.WeakKicker, 0));
}
public SuitedStatus <BoardRangeGridStatusEnum> TestSuitedGrid(RangeGrid grid)
{
return(new SuitedStatus <BoardRangeGridStatusEnum>()
{
HeartStatus = BoardRangeGridStatusEnum.Trash,
SpadeStatus = BoardRangeGridStatusEnum.Trash,
DiamondStatus = BoardRangeGridStatusEnum.Trash,
ClubStatus = BoardRangeGridStatusEnum.Trash
});
}
public bool ShouldAGridFoldToBet(RangeGrid grid)
{
var outcome = TestGridAgainstBoard(grid).Item1;
if (outcome.Grade() == RankHandGradeEnum.HighCard)
{
return(ShouldRankDrawFold(grid));
}
return(false);
}
public Dictionary <Tuple <SuitEnum, SuitEnum>, bool> ShouldAGridFoldToBet(RangeGrid grid)
{
var result = new Dictionary <Tuple <SuitEnum, SuitEnum>, bool>();
foreach (var tuple in grid.EnumerateAllPossibleHoles())
{
var hole1 = tuple.Item1;
var hole2 = tuple.Item2;
result.Add(new Tuple <SuitEnum, SuitEnum>(hole1.Suit, hole2.Suit), true);
}
return(result);
}
public PairedStatus <BoardRangeGridStatusEnum> TestPairedGrid(RangeGrid grid)
{
return(new PairedStatus <BoardRangeGridStatusEnum>()
{
HeartSpadeStatus = BoardRangeGridStatusEnum.Trash,
HeartClubStatus = BoardRangeGridStatusEnum.Trash,
HeartDiamondStatus = BoardRangeGridStatusEnum.Trash,
SpadeDiamondStatus = BoardRangeGridStatusEnum.Trash,
SpadeClubStatus = BoardRangeGridStatusEnum.Trash,
DiamondClubStatus = BoardRangeGridStatusEnum.Trash,
});
}
public Tuple <FoursomeOutcomeEnum, int> TestGridAgainstBoard(RangeGrid grid)
{
if (grid.HighRank == RankEnum.Ace)
{
return(new Tuple <FoursomeOutcomeEnum, int>(FoursomeOutcomeEnum.FoursomeTopKicker, 0));
}
if (grid.HighRank > RankEnum.Ten)
{
return(new Tuple <FoursomeOutcomeEnum, int>(FoursomeOutcomeEnum.FoursomeGoodKicker, 0));
}
return(new Tuple <FoursomeOutcomeEnum, int>(FoursomeOutcomeEnum.FoursomeWeakKicker, 0));
}
public bool ShouldAGridFoldToBet(RangeGrid grid)
{
var outcome = TestGridAgainstBoard(grid).Item1;
//todo consider betSize later
switch (outcome)
{
case ThreesomeOutcomeEnum.ThreeSomeGoodKicker:
case ThreesomeOutcomeEnum.ThreeSomeWeakKicker:
return(true);
}
return(false);
}
public bool ShouldAGridFoldToBoardByRank(RangeGrid grid, RiverBoard riverBoard)
{
switch (riverBoard.RankTexture)
{
case RiverRankTextureEnum.Foursome:
return(new FoursomeRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.HighTriLowPair:
return(new HighTriLowPairRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.LowTriHighPair:
return(new LowTriHighPairRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.HighTri:
return(new HighTriRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.MiddleTri:
return(new MiddleTriRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.LowTri:
return(new LowTriRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.HighTwoPairs:
return(new HighTwoPairsRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.HighLowTwoPairs:
return(new HighLowTwoPairsRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.LowTwoPairs:
return(new LowTwoPairsRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.HighPair:
return(new HighPairRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.SecondPair:
return(new SecondPairRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.ThirdPair:
return(new ThirdPairRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.LowPair:
return(new LowPairRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
case RiverRankTextureEnum.Singles:
return(new SinglesRankTexture(riverBoard).ShouldAGridFoldToBet(grid));
}
throw new InvalidOperationException();
}
public bool ShouldAGridFoldToBet(RangeGrid grid)
{
var outcome = TestGridAgainstBoard(grid).Item1;
//todo consider betSize later
switch (outcome)
{
case HighPairOutcomeEnum.OnePairTopKicker:
case HighPairOutcomeEnum.OnePairGoodKicker:
case HighPairOutcomeEnum.OnePairWeakKicker:
return(ShouldRankDrawFold(grid));
}
return(false);
}
public Tuple <TriOutcomeEnum, int> TestGridAgainstBoard(RangeGrid grid)
{/*
* Foursome,
* GoodOverFullHouse,
* WeakOverFullHouse,
* MiddleFullHouse,
* UnderFullHouse,
* ThreesomeTopKicker,
* ThreesomeOverGoodKicker,
* ThreesomeOverWeakKicker,
* ThreesomeNoneKicker*/
if (grid.HighRank == TriCard1.Rank || grid.LowRank == TriCard1.Rank)
{
return(new Tuple <TriOutcomeEnum, int>(TriOutcomeEnum.Foursome, 1));
}
if (grid.Category == GridCategoryEnum.Paired)
{
if (grid.HighRank == SingleCard.Rank)
{
return(new Tuple <TriOutcomeEnum, int>(TriOutcomeEnum.OverTriFullHouse, 2));
}
if (grid.HighRank > SingleCard.Rank)
{
return(grid.HighRank > RankEnum.Ten
? new Tuple <TriOutcomeEnum, int>(TriOutcomeEnum.GoodOverFullHouse, 2)
: new Tuple <TriOutcomeEnum, int>(TriOutcomeEnum.OverFullHouse, 2));
}
return(new Tuple <TriOutcomeEnum, int>(TriOutcomeEnum.UnderFullHouse, 2));
}
if (grid.HighRank == SingleCard.Rank || grid.LowRank == SingleCard.Rank)
{
return(new Tuple <TriOutcomeEnum, int>(TriOutcomeEnum.FullHouse, 1));
}
if (grid.HighRank == RankEnum.Ace)
{
return(new Tuple <TriOutcomeEnum, int>(TriOutcomeEnum.ThreesomeTopKicker, 0));
}
if (grid.HighRank > SingleCard.Rank)
{
return(grid.HighRank > RankEnum.Ten ?
new Tuple <TriOutcomeEnum, int>(TriOutcomeEnum.ThreesomeOverGoodKicker, 0)
: new Tuple <TriOutcomeEnum, int>(TriOutcomeEnum.ThreesomeOverWeakKicker, 0));
}
return(new Tuple <TriOutcomeEnum, int>(TriOutcomeEnum.ThreesomeNoneKicker, 0));
}
public static List <Tuple <Card, Card> > EnumerateAllPossibleHoles(this RangeGrid grid)
{
switch (grid.Category)
{
case GridCategoryEnum.Suited:
return(grid.EnumerateAllPossibleHolesForSuitedGrid().ToList());
case GridCategoryEnum.Paired:
return(grid.EnumerateAllPossibleHolesForPairedGrid().ToList());
case GridCategoryEnum.Offsuit:
return(grid.EnumerateAllPossibleHolesForOffsuitGrid().ToList());
default:
throw new InvalidOperationException();
}
}
public Dictionary <Tuple <SuitEnum, SuitEnum>, bool> ShouldAGridFoldToBet(RangeGrid grid)
{
var result = new Dictionary <Tuple <SuitEnum, SuitEnum>, bool>();
var suits = new List <SuitEnum>()
{
SuitEnum.Heart, SuitEnum.Spade, SuitEnum.Diamond, SuitEnum.Club
};
foreach (var suit1 in suits)
{
foreach (var suit2 in suits)
{
result.Add(new Tuple <SuitEnum, SuitEnum>(suit1, suit2), true);
}
}
return(result);
}
private bool ShouldRankDrawFold(RangeGrid grid)
{
var rankDraw =
grid.TestRankDrawOnFlop(new List <RankEnum>()
{
SingleCard.Rank, PairCard1.Rank, PairCard2.Rank
});
switch (rankDraw)
{
case RankDrawEnum.Nothing:
return(true);
default:
return(false);
}
}
public bool ShouldAGridFoldToBoardByRank(RangeGrid grid, FlopBoard flopBoard)
{
switch (flopBoard.RankTexture)
{
case FlopBoardRankTextureEnum.ThreeSome:
return(new ThreeSomeRankTexture(flopBoard).ShouldAGridFoldToBet(grid));
case FlopBoardRankTextureEnum.HighPair:
return(new HighPairRankTexture(flopBoard).ShouldAGridFoldToBet(grid));
case FlopBoardRankTextureEnum.LowPair:
return(new LowPairRankTexture(flopBoard).ShouldAGridFoldToBet(grid));
case FlopBoardRankTextureEnum.Singles:
return(new SinglesRankTexture(flopBoard).ShouldAGridFoldToBet(grid));
}
throw new NotImplementedException();
}
public OffsuitStatus <BoardRangeGridStatusEnum> TestOffsuitGrid(RangeGrid grid)
{
return(new OffsuitStatus <BoardRangeGridStatusEnum>()
{
HeartSpadeStatus = BoardRangeGridStatusEnum.Trash,
HeartClubStatus = BoardRangeGridStatusEnum.Trash,
HeartDiamondStatus = BoardRangeGridStatusEnum.Trash,
SpadeDiamondStatus = BoardRangeGridStatusEnum.Trash,
SpadeClubStatus = BoardRangeGridStatusEnum.Trash,
DiamondClubStatus = BoardRangeGridStatusEnum.Trash,
SpadeHeartStatus = BoardRangeGridStatusEnum.Trash,
ClubHeartStatus = BoardRangeGridStatusEnum.Trash,
DiamondHeartStatus = BoardRangeGridStatusEnum.Trash,
DiamondSpadeStatus = BoardRangeGridStatusEnum.Trash,
ClubSpadeStatus = BoardRangeGridStatusEnum.Trash,
ClubDiamondStatus = BoardRangeGridStatusEnum.Trash,
});
}
private BoardRangeGridStatusEnum TestGrid(FlopBoard flopBoard, RangeGrid grid)
{
switch (flopBoard.RankTexture)
{
case FlopBoardRankTextureEnum.ThreeSome:
return(new ThreeSomeRankTexture(flopBoard).TestGridAgainstFlopBoard(grid));
case FlopBoardRankTextureEnum.HighPair:
return(new HighPairRankTexture(flopBoard).TestGridAgainstFlopBoard(grid));
case FlopBoardRankTextureEnum.LowPair:
return(new LowPairRankTexture(flopBoard).TestGridAgainstFlopBoard(grid));
case FlopBoardRankTextureEnum.Singles:
return(new SinglesRankTexture(flopBoard).TestGridAgainstFlopBoard(grid));
}
throw new NotImplementedException();
}
public Tuple <ThreesomeOutcomeEnum, int> TestGridAgainstBoard(RangeGrid grid)
{
/*
* FourSomeTopKicker, //AJ
* FourSomeGoodKicker, //QJ
* FourSomeWeakKicker, //J7
* TopFullHouse, //AA
* GoodFullHouse, //QQ
* WeakFullHouse, //88
* ThreeSomeTopKicker, //AQ
* ThreeSomeGoodKicker, //QT
* ThreeSomeWeakKicker, //98
*/
if (grid.HighRank == ThreesomeCard1.Rank || grid.LowRank == ThreesomeCard1.Rank)
{
return(new Tuple <ThreesomeOutcomeEnum, int>(ThreesomeOutcomeEnum.FourSome, 1));
}
if (grid.HighRank == grid.LowRank)
{
//full house
if (grid.HighRank == RankEnum.Ace)
{
return(new Tuple <ThreesomeOutcomeEnum, int>(ThreesomeOutcomeEnum.TopFullHouse, 2));
}
if (grid.HighRank > ThreesomeCard1.Rank)
{
return(new Tuple <ThreesomeOutcomeEnum, int>(ThreesomeOutcomeEnum.GoodFullHouse, 2));
}
return(new Tuple <ThreesomeOutcomeEnum, int>(ThreesomeOutcomeEnum.WeakFullHouse, 2));
}
if (grid.HighRank == RankEnum.Ace)
{
return(new Tuple <ThreesomeOutcomeEnum, int>(ThreesomeOutcomeEnum.ThreeSomeTopKicker, 0));
}
if (grid.HighRank > RankEnum.Ten)
{
return(new Tuple <ThreesomeOutcomeEnum, int>(ThreesomeOutcomeEnum.ThreeSomeGoodKicker, 0));
}
return(new Tuple <ThreesomeOutcomeEnum, int>(ThreesomeOutcomeEnum.ThreeSomeWeakKicker, 0));
}
public GridGradeOnBoardEnum GetGridGrade(RangeGrid rangeGrid)
{
if (EliteRangeGrids.Contains(rangeGrid))
{
return(GridGradeOnBoardEnum.Elite);
}
if (EliteWhenSuitedRangeGrids.Contains(rangeGrid))
{
return(GridGradeOnBoardEnum.EliteWhenSuited);
}
if (TrashRangeGrids.Contains(rangeGrid))
{
return(GridGradeOnBoardEnum.Trash);
}
return(GridGradeOnBoardEnum.Marginal);
}
