private Decision MakeCallDecision(FlopDecisionContext context)
{
List <VillainProbabilityResult> probabilityResults = context.AliveVillains.Select(villain
=> _probabilityCalculator.Calculate(context.HeroHoles, villain,
Common.Utils.VillainFoldable(context.FlopRaiser, context.Hero, villain))).ToList();
List <List <ProbabilityTuple> > tupleLists = Common.Utils.EnumerateProbabilities(0, probabilityResults).ToList();
foreach (var tupleList in tupleLists)
{
Logger.Instance.Log($"{string.Join(";", tupleList.Select(t => $"{t.VillainName}-{t.ProbabilityCategory}-{t.Probability}"))}");
}
int callSize = context.FlopRaiser.FlopBet - context.Hero.FlopBet;
int potSize = context.CurrentPotSize;
double ev = tupleLists.Sum(tupleList => Common.Utils.CalculateEv(tupleList, callSize, potSize));
Logger.Instance.Log($"{callSize} to call a pot of size {potSize}, ev={ev}");
if (Common.Utils.EvProfitable(ev, potSize, callSize))
{
Logger.Instance.Log($"Profitable, calling");
return(new Decision(DecisionType.Call, callSize));
}
Logger.Instance.Log($"Not profitable, folding");
return(new Decision(DecisionType.Fold, 0));
}
public Decision MakeDecision(FlopDecisionContext context)
{
List <VillainProbabilityResult> probabilityResults = context.AliveVillains.Select(villain
=> _probabilityCalculator.Calculate(context.HeroHoles, villain)).ToList();
List <List <ProbabilityTuple> > tupleLists = Common.Utils.EnumerateProbabilities(0, probabilityResults).ToList();
foreach (var tupleList in tupleLists)
{
Logger.Instance.Log($"{string.Join(";", tupleList.Select(t => $"{t.VillainName}-{t.ProbabilityCategory}-{t.Probability}"))}");
}
int betSize = Common.Utils.GetBetSize(context.CurrentPotSize);
int potSize = context.CurrentPotSize;
double ev = tupleLists.Sum(tupleList => Common.Utils.CalculateEv(tupleList, betSize, potSize));
Logger.Instance.Log($"{betSize} to bet a pot of size {potSize}, ev={ev}");
if (Common.Utils.EvProfitable(ev, potSize, betSize))
{
return(new Decision(DecisionType.Raise, betSize));
}
return(new Decision(DecisionType.Check, 0));
}
public Decision MakeDecision(FlopDecisionContext context)
{
var probabilityResult = _probabilityCalculator.Calculate(context.HeroHoles,
context.HeadsUpVillain);
int betSize = Common.Utils.GetBetSize(context.CurrentPotSize);
int potSize = context.CurrentPotSize;
var ev = probabilityResult.Probabilities[ProbabilityEnum.Fold] * potSize
+ probabilityResult.Probabilities[ProbabilityEnum.CallLose] * (potSize + betSize)
- probabilityResult.Probabilities[ProbabilityEnum.CallWin] * betSize
+ probabilityResult.Probabilities[ProbabilityEnum.CallTie] * (potSize + betSize) / 2;
if (Common.Utils.EvProfitable(ev, potSize, betSize))
{
return(new Decision(DecisionType.Raise, betSize));
}
return(new Decision(DecisionType.Check, 0));
}
private Decision MakeCallDecision(FlopDecisionContext context)
{
int chipsToCall = context.FlopRaiser.FlopBet - context.Hero.FlopBet;
double potOdds = (double)chipsToCall / (context.CurrentPotSize + chipsToCall);
var raiserRange = context.FlopRaiser.FlopRange;
var equityCalculator = new EquityCalculator(new FlopFiveCardsEnumerator(context.FlopBoard, context.HeroHoles));
var equity = equityCalculator.CalculateEquity(context.HeroHoles, raiserRange);
Logger.Instance.Log($"Pot odds is {potOdds}, hero's equity is {equity} against raiser {context.FlopRaiser.Position}-{context.FlopRaiserName}'s range: {raiserRange.ToString()}");
if (equity <= potOdds)
{
Logger.Instance.Log($"Fold");
return(new Decision(DecisionType.Fold, 0));
}
Logger.Instance.Log($"Call {chipsToCall} chips");
return(new Decision(DecisionType.Call, chipsToCall));
//todo: implement the reraise logic
}
public static FlopDecisionContext GenerateFlopDecisionContext(Round round, List <PlayerRoundProfile> playerProfiles)
{
var hero = round.Players.First(round.IsMe);
var context = new FlopDecisionContext()
{
BigBlindSize = round.BigBlindSize,
CurrentPotSize = round.CurrentPotSize,
FlopBoard = new FlopBoard(round.Flop1, round.Flop2, round.Flop3),
Players = playerProfiles,
HeroName = hero.Name,
IsHeadsUp = round.Players.Count(p => p.IsAlive) == 2,
HeroHoles = new HoldingHoles(round.Hole1, round.Hole2),
PreflopRaiserName = round.PreflopRaiser.Name,
FlopRaiserName = round.FlopMoves.LastOrDefault(m => m.Decision.DecisionType.IsRaiseMove())?.Player.Name,
IsRaised = round.FlopMoves.Any(m => m.Decision.DecisionType.IsRaiseMove()),
};
if (context.IsHeadsUp)
{
context.HeadsUpVillainName = round.Players.First(p => p.IsAlive && !round.IsMe(p)).Name;
}
return(context);
}
private Decision MakeReraiseDecision(FlopDecisionContext context)
{
//todo: implement the reraise logic
return(null);
}
public Decision MakeDecision(FlopDecisionContext context)
{
var decision = MakeReraiseDecision(context) ?? MakeCallDecision(context);
return(decision);
}
