public static TurnDecisionContext GenerateTurnDecisionContext(Round round, List <PlayerRoundProfile> playerProfiles)
{
var hero = round.Players.First(round.IsMe);
var context = new TurnDecisionContext()
{
BigBlindSize = round.BigBlindSize,
CurrentPotSize = round.CurrentPotSize,
TurnBoard = new TurnBoard(new FlopBoard(round.Flop1, round.Flop2, round.Flop3), round.Turn),
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,
TurnRaiserName = round.TurnMoves.LastOrDefault(m => m.Decision.DecisionType.IsRaiseMove())?.Player.Name,
IsRaised = round.TurnMoves.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 MakeCallDecision(TurnDecisionContext context)
{
List <VillainProbabilityResult> probabilityResults = context.AliveVillains.Select(villain
=> _probabilityCalculator.Calculate(context.HeroHoles, villain,
Common.Utils.VillainFoldable(context.TurnRaiser, 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.TurnRaiser.TurnBet - context.Hero.TurnBet;
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(TurnDecisionContext context)
{
if (!_initialized)
{
Init(context);
}
if (context.IsHeadsUp)
{
if (context.IsRaised)
{
return(_callingStrategy.MakeDecision(context));
}
else
{
return(_bettingStrategy.MakeDecision(context));
}
}
else
{
if (context.IsRaised)
{
return(_multiwayCallingStrategy.MakeDecision(context));
}
else
{
return(_multiwayBettingStrategy.MakeDecision(context));
}
}
}
public Decision MakeDecision(TurnDecisionContext 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));
}
private void Init(TurnDecisionContext context)
{
_bettingStrategy = new HeadsupTurnBettingStrategy(context.TurnBoard, context.HeroHoles);
_callingStrategy = new HeadsupTurnCallingStrategy();
_multiwayBettingStrategy = new TurnMultiwayBettingStrategy(context.TurnBoard, context.HeroHoles);
_multiwayCallingStrategy = new TurnMultiwayCallingStrategy(context.TurnBoard, context.HeroHoles);
_initialized = true;
}
public Decision MakeDecision(TurnDecisionContext 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(TurnDecisionContext context)
{
int chipsToCall = context.TurnRaiser.TurnBet - context.Hero.TurnBet;
double potOdds = (double)chipsToCall / (context.CurrentPotSize + chipsToCall);
var raiserRange = context.TurnRaiser.TurnRange;
var equityCalculator = new EquityCalculator(new TurnFiveCardsEnumerator(context.TurnBoard, context.HeroHoles));
var equity = equityCalculator.CalculateEquity(context.HeroHoles, raiserRange);
Logger.Instance.Log($"Pot odds is {potOdds}, hero's equity is {equity} against raiser {context.TurnRaiser.Position}-{context.TurnRaiserName}'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
}
private Decision MakeReraiseDecision(TurnDecisionContext context)
{
//todo: implement the reraise logic
return(null);
}
public Decision MakeDecision(TurnDecisionContext context)
{
var decision = MakeReraiseDecision(context) ?? MakeCallDecision(context);
return(decision);
}
