protected override Play GetDecision()
{
Dictionary <string, decimal> networkInputs = new Dictionary <string, decimal>();
//Some values need to be moved the top because they are used in multiple places
decimal currentRoundMinPlayCallAmount = currentDecision.Cache.getMinimumPlayAmount();
decimal additionalCallAmount = currentRoundMinPlayCallAmount - infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal);
//Determine the minimumRaiseToAmount
decimal lastAdditionalRaiseAmount = currentDecision.Cache.getCurrentRoundLastRaiseAmount();
decimal minimumRaiseToAmount = (currentRoundMinPlayCallAmount - lastAdditionalRaiseAmount) + (lastAdditionalRaiseAmount * 2);
decimal currentPotAmount = infoStore.GetInfoValue(InfoType.BP_TotalPotAmount_Decimal);
decimal remainingPlayerStack = currentDecision.Cache.getPlayerStack(currentDecision.PlayerId);
long[] activePlayerIds = currentDecision.Cache.getActivePlayerIds();
//Current Round Actions
List <PokerAction> currentRoundPlayerActions = (from current in currentDecision.Cache.getPlayerCurrentRoundActions(currentDecision.PlayerId)
where current == PokerAction.Check ||
current == PokerAction.Call ||
current == PokerAction.Raise
select current).ToList();
#region RaiseAmounts
decimal raiseToCallAmountNew, raiseToStealAmountNew;
//If we are preflop we calculate the raise amounts in a slightly more fixed fashion
if (currentDecision.Cache.getBettingRound() == 0)
{
double randomNumber = randomGen.NextDouble();
//If the pot is unraised
if (infoStore.GetInfoValue(InfoType.BP_MinimumPlayAmount_Decimal) == currentDecision.Cache.BigBlind)
{
if (randomNumber > 0.8)
{
raiseToCallAmountNew = 4m * currentDecision.Cache.BigBlind;
}
else if (randomNumber > 0.4)
{
raiseToCallAmountNew = 3.5m * currentDecision.Cache.BigBlind;
}
else
{
raiseToCallAmountNew = 3.0m * currentDecision.Cache.BigBlind;
}
}
else
{
//decimal currentRoundLastRaiseAmount = infoStore.GetInfoValue(InfoType.BP_LastAdditionalRaiseAmount);
decimal additionalNewRaiseAmount;
if (randomNumber > 0.9)
{
additionalNewRaiseAmount = 2 * lastAdditionalRaiseAmount;
}
else if (randomNumber > 0.45)
{
additionalNewRaiseAmount = 1.5m * lastAdditionalRaiseAmount;
}
else
{
additionalNewRaiseAmount = 1 * lastAdditionalRaiseAmount;
}
raiseToCallAmountNew = additionalNewRaiseAmount + infoStore.GetInfoValue(InfoType.BP_MinimumPlayAmount_Decimal);
}
raiseToStealAmountNew = 1.5m * raiseToCallAmountNew;
//We will only scale the raiseToCallAmount if it is not a bigblind multiple
if (((int)(raiseToCallAmountNew / currentDecision.Cache.BigBlind)) * currentDecision.Cache.BigBlind != raiseToCallAmountNew)
{
//Round the raiseToCallAmount
decimal raiseToCallAmountBlindMultiple = raiseToCallAmountNew / currentDecision.Cache.LittleBlind;
raiseToCallAmountNew = Math.Round(raiseToCallAmountBlindMultiple, 0, MidpointRounding.AwayFromZero) * currentDecision.Cache.LittleBlind;
}
//Round the raiseToStealAmount
decimal raiseToStealAmountBlindMultiple = raiseToStealAmountNew / currentDecision.Cache.LittleBlind;
raiseToStealAmountNew = Math.Round(raiseToStealAmountBlindMultiple, 0, MidpointRounding.AwayFromZero) * currentDecision.Cache.LittleBlind;
}
else
{
raiseToCallAmountNew = (decimal)infoStore.GetInfoValue(InfoType.WR_RaiseToCallAmount);
raiseToStealAmountNew = (decimal)infoStore.GetInfoValue(InfoType.WR_RaiseToStealAmount);
}
//Some raise validation
//Validate we can actually raise the selected amounts
decimal maximumRaiseAmount = remainingPlayerStack + infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal);
//if (raiseToCallAmount > maximumRaiseAmount) raiseToCallAmount = maximumRaiseAmount;
//if (raiseToStealAmount > maximumRaiseAmount) raiseToStealAmount = maximumRaiseAmount;
//Check for a big raise amount which would be best as going all in
if (raiseToCallAmountNew > 0.8m * maximumRaiseAmount)
{
raiseToCallAmountNew = maximumRaiseAmount;
}
if (raiseToStealAmountNew > 0.8m * maximumRaiseAmount)
{
raiseToStealAmountNew = maximumRaiseAmount;
}
//If we have already raised twice this round all amounts are set to all in
bool raisedTwiceOrGreaterCurrentRound = currentRoundPlayerActions.Count(entry => entry == PokerAction.Raise) >= 2;
if (raisedTwiceOrGreaterCurrentRound)
{
raiseToCallAmountNew = maximumRaiseAmount;
raiseToStealAmountNew = maximumRaiseAmount;
}
#endregion RaiseAmounts
/////////////////////////////////////////
///////////ALL NON BOOLEAN INPUTS BETWEEN 0.9 and 0.1
/////////////////////////////////////////
#region neuralInputs
#region gameStage
decimal gameStagePreFlop = 0;
decimal gameStageFlop = 0;
decimal gameStageTurn = 0;
decimal gameStageRiver = 0;
decimal currentGameStage = infoStore.GetInfoValue(InfoType.GP_GameStage_Byte);
if (currentGameStage == 0)
{
gameStagePreFlop = 1;
}
else if (currentGameStage == 1)
{
gameStageFlop = 1;
}
else if (currentGameStage == 2)
{
gameStageTurn = 1;
}
else if (currentGameStage == 3)
{
gameStageRiver = 1;
}
else
{
throw new Exception("What sort of game stage do you call this??");
}
networkInputs.Add("GameStagePreFlop", gameStagePreFlop);
networkInputs.Add("GameStageFlop", gameStageFlop);
networkInputs.Add("GameStageTurn", gameStageTurn);
networkInputs.Add("GameStageRiver", gameStageRiver);
#endregion gameStage
//4 inputs
#region preFlop HoleCards
if (gameStagePreFlop == 1)
{
//Card info types
networkInputs.Add("HoleCardsAAPair", infoStore.GetInfoValue(InfoType.CP_HoleCardsAAPair_Bool));
networkInputs.Add("HoleCardsKKPair", infoStore.GetInfoValue(InfoType.CP_HoleCardsKKPair_Bool));
networkInputs.Add("HoleCardsAKPair", infoStore.GetInfoValue(InfoType.CP_HoleCardsAK_Bool));
networkInputs.Add("HoleCardsOtherHighPair", infoStore.GetInfoValue(InfoType.CP_HoleCardsOtherHighPair_Bool));
networkInputs.Add("HoleCardsOtherLowPair", infoStore.GetInfoValue(InfoType.CP_HoleCardsOtherLowPair_Bool));
networkInputs.Add("HoleCardsTroubleHand", infoStore.GetInfoValue(InfoType.CP_HoleCardsTroubleHand_Bool));
networkInputs.Add("HoleCardsMidConnector", infoStore.GetInfoValue(InfoType.CP_HoleCardsMidConnector_Bool));
networkInputs.Add("HoleCardsLowConnector", infoStore.GetInfoValue(InfoType.CP_HoleCardsLowConnector_Bool));
networkInputs.Add("HoleCardsSuited", infoStore.GetInfoValue(InfoType.CP_HoleCardsSuited_Bool));
}
else
{
networkInputs.Add("HoleCardsAAPair", 0);
networkInputs.Add("HoleCardsKKPair", 0);
networkInputs.Add("HoleCardsAKPair", 0);
networkInputs.Add("HoleCardsOtherHighPair", 0);
networkInputs.Add("HoleCardsOtherLowPair", 0);
networkInputs.Add("HoleCardsTroubleHand", 0);
networkInputs.Add("HoleCardsMidConnector", 0);
networkInputs.Add("HoleCardsLowConnector", 0);
networkInputs.Add("HoleCardsSuited", 0);
}
#endregion
//9 inputs
#region playerPosition and numPlayers
decimal dealerDistance = ((infoStore.GetInfoValue(InfoType.GP_DealerDistance_Byte) - 1) / (infoStore.GetInfoValue(InfoType.GP_NumActivePlayers_Byte) - 1));
decimal tablePositionEarly = 0;
decimal tablePositionMid = 0;
decimal tablePositionLate = 0;
if (dealerDistance < (1.0m / 3.0m) && dealerDistance >= 0)
{
tablePositionEarly = 1;
}
else if (dealerDistance < (2.0m / 3.0m) && dealerDistance >= 0)
{
tablePositionMid = 1;
}
else if (dealerDistance <= 1.0m && dealerDistance >= 0)
{
tablePositionLate = 1;
}
else
{
throw new Exception("Dealer distance must be between 0 and 1.");
}
networkInputs.Add("TablePositionEarly", tablePositionEarly);
networkInputs.Add("TablePositionMid", tablePositionMid);
networkInputs.Add("TablePositionLate", tablePositionLate);
networkInputs.Add("NumActivePlayers4Plus", (infoStore.GetInfoValue(InfoType.GP_NumActivePlayers_Byte) >= 4 ? 1 : 0));
networkInputs.Add("NumActivePlayers3", (infoStore.GetInfoValue(InfoType.GP_NumActivePlayers_Byte) == 3 ? 1 : 0));
networkInputs.Add("NumActivePlayers2", (infoStore.GetInfoValue(InfoType.GP_NumActivePlayers_Byte) == 2 ? 1 : 0));
networkInputs.Add("LastToAct", (infoStore.GetInfoValue(InfoType.GP_NumUnactedPlayers_Byte) == 1 ? 1 : 0));
#endregion playerPosition and numPlayers
//7 inputs
#region potCommitment and liability
decimal potCommitted = 0;
if (infoStore.GetInfoValue(InfoType.BP_PlayerMoneyInPot_Decimal) > infoStore.GetInfoValue(InfoType.BP_PlayerHandStartingStackAmount_Decimal) * 0.75m)
{
potCommitted = 1;
}
networkInputs.Add("PotCommitted", potCommitted);
//The maximum liability in our current hand, i.e.
decimal maximumLiability = 0;
decimal[] allPlayerStacks = new decimal[activePlayerIds.Length];
//Determine if anyone has a larger stack than us
bool stackLargerThanOurs = false;
for (int i = 0; i < activePlayerIds.Length; i++)
{
allPlayerStacks[i] = currentDecision.Cache.getPlayerStack(activePlayerIds[i]);
if (activePlayerIds[i] != currentDecision.PlayerId && allPlayerStacks[i] > remainingPlayerStack)
{
stackLargerThanOurs = true;
break;
}
}
if (!stackLargerThanOurs)
{
//Find the nearest largest stack
decimal nearestLargestStack = 0;
for (int i = 0; i < activePlayerIds.Length; i++)
{
if (activePlayerIds[i] != currentDecision.PlayerId && allPlayerStacks[i] > nearestLargestStack)
{
nearestLargestStack = allPlayerStacks[i];
}
}
maximumLiability = ScaleContInput(nearestLargestStack / currentDecision.Cache.MaxStack);
}
else
{
maximumLiability = ScaleContInput(remainingPlayerStack / currentDecision.Cache.MaxStack);
}
networkInputs.Add("MaximumLiability", maximumLiability);
#endregion
//2 inputs
#region Hand and Action History
List <PokerAction> allPlayerActionsCurrentHand = currentDecision.Cache.getPlayerActionsCurrentHand(currentDecision.PlayerId);
decimal callCount = (decimal)allPlayerActionsCurrentHand.Count(entry => entry == PokerAction.Call);
decimal checkCount = (decimal)allPlayerActionsCurrentHand.Count(entry => entry == PokerAction.Check);
decimal raiseCount = (decimal)allPlayerActionsCurrentHand.Count(entry => entry == PokerAction.Raise);
decimal currentHandOurAggression = 0;
currentHandOurAggression = raiseCount - (callCount + checkCount);
if (currentHandOurAggression < -6)
{
currentHandOurAggression = -6;
}
else if (currentHandOurAggression > 6)
{
currentHandOurAggression = 6;
}
networkInputs.Add("CurrentHandOurAggression", currentHandOurAggression / 6.0m);
networkInputs.Add("CurrentRoundFirstAction", (currentRoundPlayerActions.Count == 0 ? 1 : 0));
networkInputs.Add("CurrentRoundSecondAction", (currentRoundPlayerActions.Count == 1 ? 1 : 0));
networkInputs.Add("CurrentRoundThirdPlusAction", (currentRoundPlayerActions.Count >= 2 ? 1 : 0));
#endregion Hand and Round Actions
//4 inputs
#region WinRatio
decimal probWin = 1.0m - infoStore.GetInfoValue(InfoType.WR_ProbOpponentHasBetterWRFIXED);
networkInputs.Add("WRProbWin", ScaleContInput(probWin));
#endregion
//1 inputs
#region EV, RaiseAmounts and CheckPossibilitiy
decimal bigBlindEVScaleAmount = 20;
#region CallEV
//The following EV assumes we can actually call the additionaCallAmount
//We could cap the additionalCallAmount but we would then also not be able to win the total pot amount ;( again a minor error
decimal actualCallCheckEV = (currentPotAmount * probWin) - ((1.0m - probWin) * additionalCallAmount);
decimal scaledCallCheckEV = (actualCallCheckEV / currentDecision.Cache.BigBlind) / bigBlindEVScaleAmount;
if (scaledCallCheckEV > 1)
{
networkInputs.Add("ScaledCallCheckEV", 1);
}
else if (scaledCallCheckEV < -1)
{
networkInputs.Add("ScaledCallCheckEV", -1);
}
else
{
networkInputs.Add("ScaledCallCheckEV", scaledCallCheckEV);
}
#endregion
//Current scaled raise amounts
//Aditional = MaximumRaiseTo - CurrentCallAmount
decimal maximumAdditionalRaiseAmount = (infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal) + remainingPlayerStack) - (currentRoundMinPlayCallAmount);
bool raisePossible = false;
if (maximumAdditionalRaiseAmount > 0)
{
raisePossible = true;
if (lastAdditionalRaiseAmount > maximumAdditionalRaiseAmount)
{
lastAdditionalRaiseAmount = maximumAdditionalRaiseAmount;
}
decimal additionalRaiseToCallAmount = raiseToCallAmountNew - currentRoundMinPlayCallAmount; // -infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal);
decimal additionalRaiseToStealAmount = raiseToStealAmountNew - currentRoundMinPlayCallAmount; // -infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal);
if (additionalRaiseToCallAmount > maximumAdditionalRaiseAmount)
{
additionalRaiseToCallAmount = maximumAdditionalRaiseAmount;
}
else if (additionalRaiseToCallAmount < currentDecision.Cache.BigBlind)
{
additionalRaiseToCallAmount = currentDecision.Cache.BigBlind;
}
if (additionalRaiseToStealAmount > maximumAdditionalRaiseAmount)
{
additionalRaiseToStealAmount = maximumAdditionalRaiseAmount;
}
else if (additionalRaiseToStealAmount < currentDecision.Cache.BigBlind)
{
additionalRaiseToStealAmount = currentDecision.Cache.BigBlind;
}
networkInputs.Add("ScaledAdditionalRaiseToCallAmount", ScaleContInput((decimal)RaiseAmountsHelper.ScaleAdditionalRaiseAmount(currentPotAmount, currentDecision.Cache.BigBlind, lastAdditionalRaiseAmount, maximumAdditionalRaiseAmount, additionalRaiseToCallAmount)));
networkInputs.Add("ScaledAdditionalRaiseToStealAmount", ScaleContInput((decimal)RaiseAmountsHelper.ScaleAdditionalRaiseAmount(currentPotAmount, currentDecision.Cache.BigBlind, lastAdditionalRaiseAmount, maximumAdditionalRaiseAmount, additionalRaiseToStealAmount)));
}
else
{
//No raise possible, just use defaults
networkInputs.Add("ScaledAdditionalRaiseToCallAmount", ScaleContInput(0));
networkInputs.Add("ScaledAdditionalRaiseToStealAmount", ScaleContInput(0));
}
decimal probAllOpponentFoldRaiseToCall = infoStore.GetInfoValue(InfoType.WR_RaiseToCallStealSuccessProb);
decimal probAllOpponentFoldRaiseToSteal = (gameStagePreFlop == 1 ? 0 : infoStore.GetInfoValue(InfoType.WR_RaiseToStealSuccessProb));
#region RaiseToCallEV
if (raisePossible)
{
decimal potAmountAssumingAllCall = currentPotAmount;
//If we are preflop then it would be unrealistic to expect everyone to call
//For Call we assume that if there are 8 players to act after the raise we get 2 calls
//If there are 4 players to act after the raise we get 1 call
//This is the same as dividing the number of activePlayers by 4
if (gameStagePreFlop == 1)
{
//We assume anyone who has already called or raised will call again
long[] calledRaisedPlayerIds = (from current in currentDecision.Cache.getAllHandActions()
where current.actionType == PokerAction.Call || current.actionType == PokerAction.Raise
where current.playerId != currentDecision.PlayerId
select current.playerId).ToArray();
for (int i = 0; i < calledRaisedPlayerIds.Length; i++)
{
potAmountAssumingAllCall += raiseToCallAmountNew - currentDecision.Cache.getPlayerCurrentRoundBetAmount(calledRaisedPlayerIds[i]);
}
potAmountAssumingAllCall += ((decimal)(activePlayerIds.Length - 1 - calledRaisedPlayerIds.Length) / 4) * raiseToCallAmountNew;
}
else
{
for (int i = 0; i < activePlayerIds.Length; i++)
{
if (activePlayerIds[i] != currentDecision.PlayerId)
{
potAmountAssumingAllCall += raiseToCallAmountNew - currentDecision.Cache.getPlayerCurrentRoundBetAmount(activePlayerIds[i]);
}
}
}
decimal extraDollarRiskAmount = raiseToCallAmountNew - infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal);
decimal actualRaiseToCallEV = (currentPotAmount * probAllOpponentFoldRaiseToCall) + (probWin * potAmountAssumingAllCall * (1.0m - probAllOpponentFoldRaiseToCall)) - ((1.0m - probWin) * extraDollarRiskAmount * (1.0m - probAllOpponentFoldRaiseToCall));
decimal scaledRaiseToCallEV = (actualRaiseToCallEV / currentDecision.Cache.BigBlind) / bigBlindEVScaleAmount;
if (scaledRaiseToCallEV > 1)
{
networkInputs.Add("ScaledRaiseToCallEV", 1);
}
else if (scaledRaiseToCallEV < -1)
{
networkInputs.Add("ScaledRaiseToCallEV", -1);
}
else
{
networkInputs.Add("ScaledRaiseToCallEV", scaledRaiseToCallEV);
}
}
else
{
networkInputs.Add("ScaledRaiseToCallEV", networkInputs["ScaledCallCheckEV"]);
}
#endregion
#region RaiseToStealEV
if (raisePossible)
{
decimal potAmountAssumingAllCall = currentPotAmount;
//If we are preflop then it would be unrealistic to expect everyone to call
//For steal we assume that if there are 8 players to act after the raise we get 1 call
//If there are 4 players to act after the raise we get 0.5 call
//This is the same as dividing the number of activePlayers by 8
if (gameStagePreFlop == 1)
{
//We assume anyone who has already raised will call again
long[] raisedPlayerIds = (from current in currentDecision.Cache.getAllHandActions()
where current.actionType == PokerAction.Raise
where current.playerId != currentDecision.PlayerId
select current.playerId).ToArray();
for (int i = 0; i < raisedPlayerIds.Length; i++)
{
potAmountAssumingAllCall += raiseToStealAmountNew - currentDecision.Cache.getPlayerCurrentRoundBetAmount(raisedPlayerIds[i]);
}
potAmountAssumingAllCall += ((decimal)(activePlayerIds.Length - 1 - raisedPlayerIds.Length) / 8) * raiseToStealAmountNew;
}
else
{
for (int i = 0; i < activePlayerIds.Length; i++)
{
if (activePlayerIds[i] != currentDecision.PlayerId)
{
potAmountAssumingAllCall += raiseToStealAmountNew - currentDecision.Cache.getPlayerCurrentRoundBetAmount(activePlayerIds[i]);
}
}
}
decimal extraDollarRiskAmount = raiseToStealAmountNew - infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal);
decimal actualRaiseToStealEV = (currentPotAmount * probAllOpponentFoldRaiseToSteal) + (probWin * potAmountAssumingAllCall * (1.0m - probAllOpponentFoldRaiseToSteal)) - ((1.0m - probWin) * extraDollarRiskAmount * (1.0m - probAllOpponentFoldRaiseToSteal));
decimal scaledRaiseToStealEV = (actualRaiseToStealEV / currentDecision.Cache.BigBlind) / bigBlindEVScaleAmount;
if (scaledRaiseToStealEV > 1)
{
networkInputs.Add("ScaledRaiseToStealEV", 1);
}
else if (scaledRaiseToStealEV < -1)
{
networkInputs.Add("ScaledRaiseToStealEV", -1);
}
else
{
networkInputs.Add("ScaledRaiseToStealEV", scaledRaiseToStealEV);
}
}
else
{
networkInputs.Add("ScaledRaiseToStealEV", networkInputs["ScaledCallCheckEV"]);
}
#endregion
bool checkPossible = (infoStore.GetInfoValue(InfoType.BP_MinimumPlayAmount_Decimal) == infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal));
networkInputs.Add("CheckPossible", Convert.ToDecimal(checkPossible));
networkInputs.Add("CallAmount1BBOrLess", !checkPossible && ((decimal)infoStore.GetInfoValue(InfoType.BP_MinimumPlayAmount_Decimal) - (decimal)infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal)) <= currentDecision.Cache.BigBlind ? 1 : 0);
#endregion
//7 inputs
#region PAP
networkInputs.Add("ProbRaiseToStealSuccess", ScaleContInput(probAllOpponentFoldRaiseToSteal));
#endregion
//1 inputs
#region PlayerAggression
networkInputs.Add("AvgLiveOppPreFlopPlayFreq", ScaleContInput(infoStore.GetInfoValue(InfoType.AP_AvgLiveOppPreFlopPlayFreq_Double)));
networkInputs.Add("AvgLiveOppPostFlopPlayFreq", ScaleContInput(infoStore.GetInfoValue(InfoType.AP_AvgLiveOppPostFlopPlayFreq_Double)));
networkInputs.Add("AvgLiveOppCurrentRoundAggr", ScaleContInput(infoStore.GetInfoValue(InfoType.AP_AvgLiveOppCurrentRoundAggr_Double)));
networkInputs.Add("AvgLiveOppCurrentRoundAggrAcc", ScaleContInput(infoStore.GetInfoValue(InfoType.AP_AvgLiveOppCurrentRoundAggrAcc_Double)));
#endregion
//4 inputs
#region BigOrSmallPot
byte isBigPot = 0;
if (currentPotAmount > RaiseAmountsHelper.SmallPotBBMultiplierLimit * currentDecision.Cache.BigBlind)
{
isBigPot = 1;
}
networkInputs.Add("BigPot", ScaleContInput(isBigPot));
#endregion
//1 input
#region RandomInputs
//We have 2 random inputs with different periods, per hand and per decision
//Check the randomNumbers are not -1
if (currentDecision.Cache.CurrentHandRandomNumber() < 0)
{
throw new Exception("currentDecision.Cache.CurrentHandRandomNumber() should not be less than 0");
}
//We disable these random numbers for the ailwyn blank network
if (currentDecision.Cache.PokerClientId == (short)PokerClients.GeneticPokerPlayer_PlaySimpleAI_1a_FixedStart || currentDecision.Cache.PokerClientId == (short)PokerClients.GeneticPokerPlayer_PlayerSimpleAI_1b_RandomInitialisation || currentDecision.Cache.PokerClientId == (short)PokerClients.GeneticPokerPlay_PlaySimpleAI_2a || (currentDecision.AiConfigStr.StartsWith("F") && currentDecision.AiConfigStr == "FixedNeuralPlayers\\neuralV7_Ailwyn_NoRandomInput.eNN"))
{
networkInputs.Add("HandRandomNumber", 0);
networkInputs.Add("DecisionRandomNumber", 0);
}
else
{
networkInputs.Add("HandRandomNumber", ScaleContInput((decimal)currentDecision.Cache.CurrentHandRandomNumber() / (decimal)int.MaxValue));
networkInputs.Add("DecisionRandomNumber", ScaleContInput((decimal)randomGen.NextDouble()));
}
#endregion
//2 inputs
#endregion neuralInputs
NNDataSource aiDecisionData = new NNDataSource(networkInputs.Values.ToArray(), NeuralAINNModelV7.Input_Neurons, true);
if (true)
{
//Get the network outputs
double[] networkInputsArray = null;
aiDecisionData.returnInput(ref networkInputsArray);
double[] networkOutput = getPlayerNetworkPrediction(currentDecision.AiConfigStr, networkInputsArray);
//Blank the non possible actions
if (checkPossible)
{
//Blank fold
networkOutput[0] = 0;
//Blank call
networkOutput[2] = 0;
}
else
{
//Blank check
networkOutput[1] = 0;
}
//Get the bot decision
NeuralAiDecisionNeuralv7 decision = new NeuralAiDecisionNeuralv7(networkOutput, !Convert.ToBoolean(gameStageRiver), randomGen.NextDouble());
Debug.Print("Decision");
//Can now check the fold decision for aces
//if (decision.BotAction == 0 && networkInputs["HoleCardsAAPair"] == 1 && gameStagePreFlop == 1 && currentDecision.AiConfigStr.StartsWith("GeneticPokerPlayers"))
//{
// currentDecision.Cache.SaveToDisk("", currentDecision.PlayerId + "-" + InfoProviderBase.CurrentJob.JobId + "-" + currentDecision.Cache.getCurrentHandId() + "-" + currentDecision.Cache.getMostRecentLocalIndex()[1]);
//}
if (decision.BotAction == 0)
{
return(new Play(PokerAction.Fold, 0, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0));
}
else if (decision.BotAction == 1)
{
return(new Play(PokerAction.Check, 0, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0));
}
else if (decision.BotAction == 2)
{
return(new Play(PokerAction.Call, additionalCallAmount, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0));
}
else if (decision.BotAction == 3)
{
bool isSmallPot = currentPotAmount < RaiseAmountsHelper.SmallPotBBMultiplierLimit * currentDecision.Cache.BigBlind * ((decimal)(randomGen.NextDouble() * 0.2) + 0.80m);
//////////////////////////////////////////////////////////
///////////////// START VANAHEIM FIX /////////////////////
//////////////////////////////////////////////////////////
//We add a temporary fix here for vanaheim which is playing mid pocket pairs a little strongly
//If we have pocket pair lower than (not including KK) have already raised and are trying to raise again we fold
//if (currentDecision.AiConfigStr.StartsWith("F") && !isSmallPot && gameStagePreFlop == 1 && currentDecision.AiConfigStr == "FixedNeuralPlayers\\neuralV7_Vanaheim.eNN")
//{
// bool highPair = infoStore.GetInfoValue(InfoType.CP_HoleCardsOtherHighPair_Bool) == 1.0m;
// bool midPair = infoStore.GetInfoValue(InfoType.CP_HoleCardsOtherLowPair_Bool) == 1.0m;
// if (highPair || midPair)
// {
// if (currentRoundPlayerActions.Count(entry => entry == PokerAction.Raise) >= 1)
// {
// if (actualCallCheckEV > 0 && (tablePositionLate == 1 || tablePositionMid == 1) && currentRoundPlayerActions.Count(entry => entry == PokerAction.Call) == 0)
// return new Play(PokerAction.Call, additionalCallAmount, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0);
// else
// return new Play(PokerAction.Fold, 0, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0);
// }
// }
//}
////////////////////////////////////////////////////////////////////
/////////////////// END VANAHEIM FIX /////////////////////
////////////////////////////////////////////////////////////////////
//Make sure raiseAmount is multiple of small blind
if (raisePossible)
{
decimal raiseToAmount, raiseAmountBlindMultiple;
/////////////////////
//GENETIC OR VANAHEIM 2 PLAYER FIX
////////////////////
if (raisedTwiceOrGreaterCurrentRound && gameStagePreFlop == 1 && (currentDecision.AiConfigStr.StartsWith("G") || currentDecision.AiConfigStr == "FixedNeuralPlayers\\neuralV7_Vanaheim.eNN"))
{
//Genetic players will now go all in on their third raise preflop
raiseToAmount = maximumRaiseAmount;
}
else
{
decimal additionalRaiseAmount = RaiseAmountsHelper.UnscaleAdditionalRaiseAmount(currentPotAmount, currentDecision.Cache.BigBlind, lastAdditionalRaiseAmount, maximumAdditionalRaiseAmount, decision.ScaledAdditionalRaiseAmount);
//If the pot is currently small we raise in increments of big blind instead of little blind
//We add a little randomness into this limit so that it's not always exact, random number is between 0.8 and 1.0
if (isSmallPot)
{
///////////////////////////////////////
///// START VANAHEIM FIX //////////////
///////////////////////////////////////
//If we are preflop with a small pot playing as vanaheim
//And we do not have AA or KK we can only raise to a set maximum
//if (currentDecision.AiConfigStr.StartsWith("F") && gameStagePreFlop == 1 && currentDecision.AiConfigStr == "FixedNeuralPlayers\\neuralV7_Vanaheim.eNN")
//{
// bool AAPair = infoStore.GetInfoValue(InfoType.CP_HoleCardsAAPair_Bool) == 1.0m;
// bool KKPair = infoStore.GetInfoValue(InfoType.CP_HoleCardsKKPair_Bool) == 1.0m;
// decimal maxDesiredRaise = RaiseAmountsHelper.SmallPotBBMultiplierLimit * currentDecision.Cache.BigBlind;
// if (!(AAPair || KKPair) && additionalRaiseAmount > maxDesiredRaise)
// additionalRaiseAmount = maxDesiredRaise;
//}
///////////////////////////////////////
///// START VANAHEIM FIX //////////////
///////////////////////////////////////
raiseAmountBlindMultiple = (currentRoundMinPlayCallAmount + additionalRaiseAmount) / currentDecision.Cache.BigBlind;
raiseToAmount = Math.Round(raiseAmountBlindMultiple, 0, MidpointRounding.AwayFromZero) * currentDecision.Cache.BigBlind;
}
else
{
raiseAmountBlindMultiple = (currentRoundMinPlayCallAmount + additionalRaiseAmount) / currentDecision.Cache.LittleBlind;
raiseToAmount = Math.Round(raiseAmountBlindMultiple, 0, MidpointRounding.AwayFromZero) * currentDecision.Cache.LittleBlind;
}
//If we are going to raise almost maximum then it might as well be max
if (raiseToAmount > maximumRaiseAmount * 0.9m)
{
raiseToAmount = maximumRaiseAmount;
}
}
return(new Play(PokerAction.Raise, raiseToAmount, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0));
}
else
{
return(new Play(PokerAction.Call, additionalCallAmount, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0));
}
}
else
{
throw new Exception("Something has gone wery wong!");
}
}
decisionLogStr = aiDecisionData.ToStringAdv(true);
return(new Play(PokerAction.Fold, 0, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0));
}
/// <summary>
/// Returns a players additional raise amounts in a binned format between 0 and 1 using the provided binWidth. Anything greater than 1 will be added to an additional bin at the end.
/// </summary>
/// <param name="playerId"></param>
/// <param name="binWidth"></param>
/// <returns></returns>
public static void PlayerAdditionalRaiseAmountsBinned(long playerId, decimal binWidth, out int[] preFlopBinsSmall, out int[] flopBinsSmall, out int[] turnBinsSmall, out int[] riverBinsSmall,
out int[] preFlopBinsBig, out int[] flopBinsBig, out int[] turnBinsBig, out int[] riverBinsBig)
{
PlayerAverageAdditionalRaiseAmountResult[] playerData = PlayerAdditionalRaiseAmountsRaw(playerId);
//Setup bins
int numBins = (int)(1.0m / binWidth) + 1;
preFlopBinsSmall = new int[numBins];
flopBinsSmall = new int[numBins];
turnBinsSmall = new int[numBins];
riverBinsSmall = new int[numBins];
preFlopBinsBig = new int[numBins];
flopBinsBig = new int[numBins];
turnBinsBig = new int[numBins];
riverBinsBig = new int[numBins];
//Fill bins
for (int i = 0; i < playerData.Length; i++)
{
//Calculate the info we need to know about the scaled amount
double scaledRaiseAmount = RaiseAmountsHelper.ScaleAdditionalRaiseAmount(playerData[i].currentPotAmount, playerData[i].bigBlind, playerData[i].minAdditionalRaiseAmount, playerData[i].maxAdditionalRaiseAmount, playerData[i].additionalRaiseAmountToScale);
bool smallPot = playerData[i].currentPotAmount <= RaiseAmountsHelper.SmallPotBBMultiplierLimit * playerData[i].bigBlind;
int binIndex = (int)(scaledRaiseAmount / (double)binWidth);
//Anything larger than the last bin just gets put there
if (binIndex > numBins - 1)
{
binIndex = numBins - 1;
}
if (smallPot)
{
if (playerData[i].gameStage == 0)
{
preFlopBinsSmall[binIndex]++;
}
else if (playerData[i].gameStage == 1)
{
flopBinsSmall[binIndex]++;
}
else if (playerData[i].gameStage == 2)
{
turnBinsSmall[binIndex]++;
}
else if (playerData[i].gameStage == 3)
{
riverBinsSmall[binIndex]++;
}
else
{
throw new Exception("Impossible gameStage provided.");
}
}
else
{
if (playerData[i].gameStage == 0)
{
preFlopBinsBig[binIndex]++;
}
else if (playerData[i].gameStage == 1)
{
flopBinsBig[binIndex]++;
}
else if (playerData[i].gameStage == 2)
{
turnBinsBig[binIndex]++;
}
else if (playerData[i].gameStage == 3)
{
riverBinsBig[binIndex]++;
}
else
{
throw new Exception("Impossible gameStage provided.");
}
}
}
}
protected override Play GetDecision()
{
//If we are on the river then probWin can be 1 or 0
decimal probWin = 1.0m - infoStore.GetInfoValue(InfoType.WR_ProbOpponentHasBetterWRFIXED);
bool topHand = false;
byte currentBettingRound = currentDecision.Cache.getBettingRound();
//Some values need to be moved the top because they are used in multiple places
decimal currentRoundMinPlayCallAmount = infoStore.GetInfoValue(InfoType.BP_MinimumPlayAmount_Decimal);
decimal additionalCallAmount = currentRoundMinPlayCallAmount - infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal);
decimal currentPotAmount = infoStore.GetInfoValue(InfoType.BP_TotalPotAmount_Decimal);
decimal remainingPlayerStack = currentDecision.Cache.getPlayerStack(currentDecision.PlayerId);
long[] activePlayerIds = currentDecision.Cache.getActivePlayerIds();
var ourCards = currentDecision.Cache.getPlayerHoleCards(currentDecision.PlayerId);
int decision = 0;
//Current Round Actions
List <PokerAction> currentRoundPlayerActions = (from current in currentDecision.Cache.getPlayerCurrentRoundActions(currentDecision.PlayerId)
where current == PokerAction.Check ||
current == PokerAction.Call ||
current == PokerAction.Raise
select current).ToList();
PokerAction playerLastActionCurrentRound = PokerAction.NoAction;
if (currentRoundPlayerActions.Count > 0)
{
playerLastActionCurrentRound = currentRoundPlayerActions.Last();
}
#region RaiseAmounts
decimal raiseToCallAmountNew, raiseToStealAmountNew;
decimal maximumRaiseToAmount = remainingPlayerStack + (decimal)infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal);
decimal lastAdditionalRaiseAmount = currentDecision.Cache.getCurrentRoundLastRaiseAmount();
if (lastAdditionalRaiseAmount > remainingPlayerStack)
{
lastAdditionalRaiseAmount = remainingPlayerStack;
}
bool littlePot = (currentPotAmount < RaiseAmountsHelper.SmallPotBBMultiplierLimit * currentDecision.Cache.BigBlind * ((decimal)(randomGen.NextDouble() * 0.2) + 0.80m));
double randomNumber1 = randomGen.NextDouble();
double randomNumber2 = randomGen.NextDouble();
double raiseToCallRandomNumber = Math.Min(randomNumber1, randomNumber2);
double raiseToStealRandomNumber = Math.Max(randomNumber1, randomNumber2);
int raiseToCallIndex = -1, raiseToStealIndex = -1;
//If we have already raised twice this round all amounts are set to all in
if (currentRoundPlayerActions.Count(entry => entry == PokerAction.Raise) >= 2)
{
raiseToCallAmountNew = maximumRaiseToAmount;
raiseToStealAmountNew = maximumRaiseToAmount;
}
else
{
#region Select RaiseIndex
if (currentBettingRound == 0)
{
for (byte raiseIndex = 0; raiseIndex < 10; raiseIndex += 1)
{
if (raiseToCallIndex < 0 && raiseToCallRandomNumber < RaiseAmountsHelper.PreFlopRaiseBinIdealCDF[raiseIndex])
{
raiseToCallIndex = raiseIndex;
}
if (raiseToStealRandomNumber < RaiseAmountsHelper.PreFlopRaiseBinIdealCDF[raiseIndex])
{
raiseToStealIndex = raiseIndex;
break;
}
}
}
else if (currentBettingRound == 1)
{
if (littlePot)
{
for (byte raiseIndex = 0; raiseIndex < 10; raiseIndex += 1)
{
if (raiseToCallIndex < 0 && raiseToCallRandomNumber < RaiseAmountsHelper.FlopRaiseBinIdealSmallCDF[raiseIndex])
{
raiseToCallIndex = raiseIndex;
}
if (raiseToStealRandomNumber < RaiseAmountsHelper.FlopRaiseBinIdealSmallCDF[raiseIndex])
{
raiseToStealIndex = raiseIndex;
break;
}
}
}
else
{
for (byte raiseIndex = 0; raiseIndex < 10; raiseIndex += 1)
{
if (raiseToCallIndex < 0 && raiseToCallRandomNumber < RaiseAmountsHelper.FlopRaiseBinIdealBigCDF[raiseIndex])
{
raiseToCallIndex = raiseIndex;
}
if (raiseToStealRandomNumber < RaiseAmountsHelper.FlopRaiseBinIdealBigCDF[raiseIndex])
{
raiseToStealIndex = raiseIndex;
break;
}
}
}
}
else if (currentBettingRound == 2)
{
if (littlePot)
{
for (byte raiseIndex = 0; raiseIndex < 10; raiseIndex += 1)
{
if (raiseToCallIndex < 0 && raiseToCallRandomNumber < RaiseAmountsHelper.TurnRaiseBinIdealSmallCDF[raiseIndex])
{
raiseToCallIndex = raiseIndex;
}
if (raiseToStealRandomNumber < RaiseAmountsHelper.TurnRaiseBinIdealSmallCDF[raiseIndex])
{
raiseToStealIndex = raiseIndex;
break;
}
}
}
else
{
for (byte raiseIndex = 0; raiseIndex < 10; raiseIndex += 1)
{
if (raiseToCallIndex < 0 && raiseToCallRandomNumber < RaiseAmountsHelper.TurnRaiseBinIdealBigCDF[raiseIndex])
{
raiseToCallIndex = raiseIndex;
}
if (raiseToStealRandomNumber < RaiseAmountsHelper.TurnRaiseBinIdealBigCDF[raiseIndex])
{
raiseToStealIndex = raiseIndex;
break;
}
}
}
}
else if (currentBettingRound == 3)
{
if (littlePot)
{
for (byte raiseIndex = 0; raiseIndex < 10; raiseIndex += 1)
{
if (raiseToCallIndex < 0 && raiseToCallRandomNumber < RaiseAmountsHelper.RiverRaiseBinIdealSmallCDF[raiseIndex])
{
raiseToCallIndex = raiseIndex;
}
if (raiseToStealRandomNumber < RaiseAmountsHelper.RiverRaiseBinIdealSmallCDF[raiseIndex])
{
raiseToStealIndex = raiseIndex;
break;
}
}
}
else
{
for (byte raiseIndex = 0; raiseIndex < 10; raiseIndex += 1)
{
if (raiseToCallIndex < 0 && raiseToCallRandomNumber < RaiseAmountsHelper.RiverRaiseBinIdealBigCDF[raiseIndex])
{
raiseToCallIndex = raiseIndex;
}
if (raiseToStealRandomNumber < RaiseAmountsHelper.RiverRaiseBinIdealBigCDF[raiseIndex])
{
raiseToStealIndex = raiseIndex;
break;
}
}
}
}
else
{
throw new Exception("Impossible!");
}
#endregion
decimal additionalRaiseToCallAmountNew = RaiseAmountsHelper.UnscaleAdditionalRaiseAmount(currentPotAmount, currentDecision.Cache.BigBlind, lastAdditionalRaiseAmount, remainingPlayerStack, raiseToCallIndex / 10.0 + 0.05);
decimal additionalRaiseToStealAmountNew = RaiseAmountsHelper.UnscaleAdditionalRaiseAmount(currentPotAmount, currentDecision.Cache.BigBlind, lastAdditionalRaiseAmount, remainingPlayerStack, raiseToStealIndex / 10.0 + 0.05);
if (littlePot)
{
decimal raiseAmountBlindMultipleCall = (currentRoundMinPlayCallAmount + additionalRaiseToCallAmountNew) / currentDecision.Cache.BigBlind;
raiseToCallAmountNew = Math.Round(raiseAmountBlindMultipleCall, 0, MidpointRounding.AwayFromZero) * currentDecision.Cache.BigBlind;
decimal raiseAmountBlindMultipleSteal = (currentRoundMinPlayCallAmount + additionalRaiseToStealAmountNew) / currentDecision.Cache.BigBlind;
raiseToStealAmountNew = Math.Round(raiseAmountBlindMultipleSteal, 0, MidpointRounding.AwayFromZero) * currentDecision.Cache.BigBlind;
}
else
{
decimal raiseAmountBlindMultipleCall = (currentRoundMinPlayCallAmount + additionalRaiseToCallAmountNew) / currentDecision.Cache.LittleBlind;
raiseToCallAmountNew = Math.Round(raiseAmountBlindMultipleCall, 0, MidpointRounding.AwayFromZero) * currentDecision.Cache.LittleBlind;
decimal raiseAmountBlindMultipleSteal = (currentRoundMinPlayCallAmount + additionalRaiseToStealAmountNew) / currentDecision.Cache.LittleBlind;
raiseToStealAmountNew = Math.Round(raiseAmountBlindMultipleSteal, 0, MidpointRounding.AwayFromZero) * currentDecision.Cache.LittleBlind;
}
//Check for a big raise amount which would be best as going all in
if (raiseToCallAmountNew > 0.9m * maximumRaiseToAmount)
{
raiseToCallAmountNew = maximumRaiseToAmount;
}
if (raiseToStealAmountNew > 0.9m * maximumRaiseToAmount)
{
raiseToStealAmountNew = maximumRaiseToAmount;
}
}
#endregion RaiseAmounts
#region EV and CheckPossibilitiy
decimal bigBlindEVScaleAmount = 20;
#region CallEV
//The following EV assumes we can actually call the additionaCallAmount
//We could cap the additionalCallAmount but we would then also not be able to win the total pot amount ;( again a minor error
decimal actualCallCheckEV = (currentPotAmount * probWin) - ((1.0m - probWin) * additionalCallAmount);
decimal scaledCallCheckEV = (actualCallCheckEV / currentDecision.Cache.BigBlind) / bigBlindEVScaleAmount;
#endregion
//We can raise if we have more stack than the current additional call amount
//If we can't raise the raiseEV's get set to the callEV (which may be negative)
bool raisePossible = (remainingPlayerStack > additionalCallAmount);
bool checkPossible = (infoStore.GetInfoValue(InfoType.BP_MinimumPlayAmount_Decimal) == infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal));
decimal probAllOpponentFoldRaiseToCall = (currentBettingRound == 0 ? 0 : infoStore.GetInfoValue(InfoType.WR_RaiseToCallStealSuccessProb));
decimal probAllOpponentFoldRaiseToSteal = (currentBettingRound == 0 ? 0 : infoStore.GetInfoValue(InfoType.WR_RaiseToStealSuccessProb));
#region RaiseToCallEV
decimal scaledRaiseToCallEV = scaledCallCheckEV;
if (raisePossible)
{
decimal potAmountAssumingAllCall = currentPotAmount;
//If we are preflop then it would be unrealistic to expect everyone to call
//For Call we assume that if there are 8 players to act after the raise we get 2 calls
//If there are 4 players to act after the raise we get 1 call
//This is the same as dividing the number of activePlayers by 4
if (currentBettingRound == 0)
{
//We assume anyone who has already called or raised will call again
long[] calledRaisedPlayerIds = (from current in currentDecision.Cache.getAllHandActions()
where current.actionType == PokerAction.Call || current.actionType == PokerAction.Raise
where current.playerId != currentDecision.PlayerId
select current.playerId).ToArray();
for (int i = 0; i < calledRaisedPlayerIds.Length; i++)
{
potAmountAssumingAllCall += raiseToCallAmountNew - currentDecision.Cache.getPlayerCurrentRoundBetAmount(calledRaisedPlayerIds[i]);
}
potAmountAssumingAllCall += ((decimal)(activePlayerIds.Length - 1 - calledRaisedPlayerIds.Length) / 4) * raiseToCallAmountNew;
}
else
{
for (int i = 0; i < activePlayerIds.Length; i++)
{
if (activePlayerIds[i] != currentDecision.PlayerId)
{
potAmountAssumingAllCall += raiseToCallAmountNew - currentDecision.Cache.getPlayerCurrentRoundBetAmount(activePlayerIds[i]);
}
}
}
decimal extraDollarRiskAmount = raiseToCallAmountNew - infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal);
decimal actualRaiseToCallEV = (currentPotAmount * probAllOpponentFoldRaiseToCall) + (probWin * potAmountAssumingAllCall * (1.0m - probAllOpponentFoldRaiseToCall)) - ((1.0m - probWin) * extraDollarRiskAmount * (1.0m - probAllOpponentFoldRaiseToCall));
scaledRaiseToCallEV = (actualRaiseToCallEV / currentDecision.Cache.BigBlind) / bigBlindEVScaleAmount;
}
#endregion
#region RaiseToStealEV
decimal scaledRaiseToStealEV = scaledCallCheckEV;
if (raisePossible)
{
decimal potAmountAssumingAllCall = currentPotAmount;
//If we are preflop then it would be unrealistic to expect everyone to call
//For steal we assume that if there are 8 players to act after the raise we get 1 call
//If there are 4 players to act after the raise we get 0.5 call
//This is the same as dividing the number of activePlayers by 8
if (currentBettingRound == 0)
{
//We assume anyone who has already raised will call again
long[] raisedPlayerIds = (from current in currentDecision.Cache.getAllHandActions()
where current.actionType == PokerAction.Raise
where current.playerId != currentDecision.PlayerId
select current.playerId).ToArray();
for (int i = 0; i < raisedPlayerIds.Length; i++)
{
potAmountAssumingAllCall += raiseToStealAmountNew - currentDecision.Cache.getPlayerCurrentRoundBetAmount(raisedPlayerIds[i]);
}
potAmountAssumingAllCall += ((decimal)(activePlayerIds.Length - 1 - raisedPlayerIds.Length) / 8) * raiseToStealAmountNew;
}
else
{
for (int i = 0; i < activePlayerIds.Length; i++)
{
if (activePlayerIds[i] != currentDecision.PlayerId)
{
potAmountAssumingAllCall += raiseToStealAmountNew - currentDecision.Cache.getPlayerCurrentRoundBetAmount(activePlayerIds[i]);
}
}
}
decimal extraDollarRiskAmount = raiseToStealAmountNew - infoStore.GetInfoValue(InfoType.BP_PlayerBetAmountCurrentRound_Decimal);
decimal actualRaiseToStealEV = (currentPotAmount * probAllOpponentFoldRaiseToSteal) + (probWin * potAmountAssumingAllCall * (1.0m - probAllOpponentFoldRaiseToSteal)) - ((1.0m - probWin) * extraDollarRiskAmount * (1.0m - probAllOpponentFoldRaiseToSteal));
scaledRaiseToStealEV = (actualRaiseToStealEV / currentDecision.Cache.BigBlind) / bigBlindEVScaleAmount;
}
#endregion
#endregion
#region playerPosition and numPlayers
decimal dealerDistance = ((infoStore.GetInfoValue(InfoType.GP_DealerDistance_Byte) - 1) / (infoStore.GetInfoValue(InfoType.GP_NumActivePlayers_Byte) - 1));
bool tablePositionEarly = false;
bool tablePositionMid = false;
bool tablePositionLate = false;
if (dealerDistance < (1.0m / 3.0m) && dealerDistance >= 0)
{
tablePositionEarly = true;
}
else if (dealerDistance < (2.0m / 3.0m) && dealerDistance >= 0)
{
tablePositionMid = true;
}
else if (dealerDistance <= 1.0m && dealerDistance >= 0)
{
tablePositionLate = true;
}
else
{
throw new Exception("Dealer distance must be between 0 and 1.");
}
bool lastToAct = infoStore.GetInfoValue(InfoType.GP_NumUnactedPlayers_Byte) == 1;
#endregion playerPosition and numPlayers
#region Hand and Action History
List <PokerAction> allPlayerActionsCurrentHand = currentDecision.Cache.getPlayerActionsCurrentHand(currentDecision.PlayerId);
decimal callCount = (decimal)allPlayerActionsCurrentHand.Count(entry => entry == PokerAction.Call);
decimal checkCount = (decimal)allPlayerActionsCurrentHand.Count(entry => entry == PokerAction.Check);
decimal raiseCount = (decimal)allPlayerActionsCurrentHand.Count(entry => entry == PokerAction.Raise);
decimal currentHandOurAggression = raiseCount - (callCount + checkCount);
#endregion
#region potCommitment
bool potCommitted = false;
if (infoStore.GetInfoValue(InfoType.BP_PlayerMoneyInPot_Decimal) > infoStore.GetInfoValue(InfoType.BP_PlayerHandStartingStackAmount_Decimal) * 0.75m)
{
potCommitted = true;
}
#endregion
if (currentBettingRound == 0)
{
#region Preflop
decimal holeCardsPlayability = infoStore.GetInfoValue(InfoType.CP_HoleCardsMatchedPlayability);
byte numCallers = (byte)infoStore.GetInfoValue(InfoType.BP_TotalNumCalls_Byte);
//Used an odd format to allow multiple fall through all statements
//i.e. we can use break; to go to the end of the loop
while (true)
{
if (holeCardsPlayability == 1)
{
if (playerLastActionCurrentRound == PokerAction.Raise && topHand && randomGen.NextDouble() > 0.8)
{
decision = 4;
raiseToStealAmountNew = currentRoundMinPlayCallAmount + remainingPlayerStack;
break;
}
else
{
decision = 3;
break;
}
}
//If we are required to call an amount greater than 10 times the big blind ($2.50) on 0.25 tables and we dont have AA, KK we fold
if (additionalCallAmount > currentDecision.Cache.BigBlind * 10 && !topHand)
{
break;
}
if (holeCardsPlayability >= 0.9m)
{
if (playerLastActionCurrentRound == PokerAction.Raise && topHand && randomGen.NextDouble() > 0.9)
{
decision = 4;
raiseToStealAmountNew = currentRoundMinPlayCallAmount + remainingPlayerStack;
break;
}
else if (tablePositionLate &&
currentRoundMinPlayCallAmount > currentDecision.Cache.BigBlind &&
scaledCallCheckEV > 0 && scaledRaiseToCallEV > scaledCallCheckEV)
{
//Late position, raised pot, 80% reraise
if (randomGen.NextDouble() > 0.20 && playerLastActionCurrentRound != PokerAction.Raise)
{
decision = 3;
}
else
{
decision = 2;
}
break;
}
else if (currentRoundMinPlayCallAmount > currentDecision.Cache.BigBlind &&
(scaledCallCheckEV > 0 || (additionalCallAmount <= 4 * currentDecision.Cache.BigBlind && scaledCallCheckEV > -0.1m) || topHand))
{
//Not late, raised pot, call
decision = 2;
if (scaledRaiseToCallEV > 0 &&
playerLastActionCurrentRound != PokerAction.Raise &&
randomGen.NextDouble() > 0.50)
{
decision = 3;
}
break;
}
else if (currentRoundMinPlayCallAmount == currentDecision.Cache.BigBlind)
{
//Unraised, there is 90% prob we will raise
if (randomGen.NextDouble() > 0.1)
{
decision = 3;
}
else
{
decision = 2;
}
break;
}
}
if (holeCardsPlayability >= 0.75m)
{
//Early position, raised pot
if (tablePositionEarly && currentRoundMinPlayCallAmount > currentDecision.Cache.BigBlind &&
(scaledCallCheckEV > 0 || (additionalCallAmount <= 4 * currentDecision.Cache.BigBlind && scaledCallCheckEV > -0.2m) || topHand))
{
decision = 2;
break;
}
//Not early, raised pot
if (!tablePositionEarly && currentRoundMinPlayCallAmount > currentDecision.Cache.BigBlind &&
(scaledCallCheckEV > 0 || (additionalCallAmount <= 4 * currentDecision.Cache.BigBlind && scaledCallCheckEV > -0.2m) || topHand))
{
decision = 2;
if (raiseToCallAmountNew <= 8 * currentDecision.Cache.BigBlind && randomGen.NextDouble() > 0.5)
{
decision = 3;
}
break;
}
//Unraised pot
else if (currentRoundMinPlayCallAmount == currentDecision.Cache.BigBlind)
{
if (randomGen.NextDouble() > 0.1)
{
decision = 3;
}
else
{
decision = 2;
}
break;
}
}
if (holeCardsPlayability >= 0.6m)
{
if (tablePositionEarly &&
(scaledCallCheckEV > 0 || (additionalCallAmount <= 4 * currentDecision.Cache.BigBlind && scaledCallCheckEV > -0.1m) || topHand))
{
decision = 2;
break;
}
else if ((scaledCallCheckEV > 0 || (additionalCallAmount <= 4 * currentDecision.Cache.BigBlind && scaledCallCheckEV > -0.15m) || topHand))
{
decision = 2;
break;
}
}
if (holeCardsPlayability >= 0.5m)
{
if (tablePositionLate &&
(scaledCallCheckEV > 0 || (additionalCallAmount <= 4 * currentDecision.Cache.BigBlind && scaledCallCheckEV > -0.15m) || topHand))
{
decision = 2;
break;
}
else if ((playerLastActionCurrentRound == PokerAction.Call || playerLastActionCurrentRound == PokerAction.Raise) &&
(scaledCallCheckEV > 0 || (additionalCallAmount <= 4 * currentDecision.Cache.BigBlind && scaledCallCheckEV > -0.15m) || topHand))
{
decision = 2;
break;
}
}
if (holeCardsPlayability >= 0.3m)
{
if (currentRoundMinPlayCallAmount == currentDecision.Cache.BigBlind)
{
decision = 2;
break;
}
else if (tablePositionLate && (playerLastActionCurrentRound == PokerAction.Call || playerLastActionCurrentRound == PokerAction.Raise) &&
(scaledCallCheckEV > 0 || (additionalCallAmount <= 4 * currentDecision.Cache.BigBlind && scaledCallCheckEV > -0.1m) || topHand))
{
decision = 2;
break;
}
}
if (holeCardsPlayability >= 0.25m)
{
if (tablePositionLate && currentRoundMinPlayCallAmount == currentDecision.Cache.BigBlind)
{
decision = 2;
break;
}
}
if (holeCardsPlayability >= 0.1m)
{
if (tablePositionLate && numCallers >= 2 && currentRoundMinPlayCallAmount == currentDecision.Cache.BigBlind)
{
decision = 2;
break;
}
else if (topHand)
{
decision = 2;
break;
}
}
//We only fall through once
break;
}
#endregion
}
else
{
#region PostFlop Strategy
//decimal playEVThreshold = 0.05m;
decimal playEVThreshold = 0;
//Need some form of opponent aggression factor to use in scaling the slow play
//Scaled between 0 and 1 for aggression between 0.01 and 10
//Default value is approx 0.57
double avgOppAggression = (double)infoStore.GetInfoValue(InfoType.AP_AvgLiveOppCurrentRoundAggr_Double);
//If we have hit big
if (probWin > 0.95m)
{
#region BigHit
//River only
if (currentBettingRound == 3)
{
#region River BigHit
//Has our opponent raised every round? If so we will check again here
if (tablePositionEarly && checkPossible && playerLastActionCurrentRound == PokerAction.NoAction)
{
//What is our opponent aggression this hand?
double averageOpponentAggression = 0;
for (int i = 0; i < activePlayerIds.Length; i++)
{
if (activePlayerIds[i] != currentDecision.PlayerId)
{
List <PokerAction> allOpponentActions = currentDecision.Cache.getPlayerActionsCurrentHandPostFlop(activePlayerIds[i]);
double currentHandOpponentAggression = allOpponentActions.Count(entry => entry == PokerAction.Raise) -
(allOpponentActions.Count(entry => entry == PokerAction.Call) + allOpponentActions.Count(entry => entry == PokerAction.Check));
averageOpponentAggression += currentHandOpponentAggression;
}
}
averageOpponentAggression /= (double)(activePlayerIds.Length - 1);
if (averageOpponentAggression >= 2 || randomGen.NextDouble() < (avgOppAggression - 0.8))
{
decision = 1;
Debug.WriteLine("Checking with a whopper on the river hoping you will raise, aggressive SOB!");
}
else
{
Debug.WriteLine("Raising with my big one on river as you havn't been very aggressive.");
//When we are on the river we play differently with big hits
//We will always 'atleast' raise to call with a really good hand
decision = 3;
//We may occasionaly raiseToSteal on the river with a good hand to keep opponenents guessing
if (scaledRaiseToStealEV > scaledRaiseToCallEV && randomGen.NextDouble() > 0.75)
{
decision = 4;
}
}
}
else
{
Debug.WriteLine("Raising with big hit on river as it looks like you have nothing. Pay me!");
//When we are on the river we play differently with big hits
//We will always 'atleast' raise to call with a really good hand
decision = 3;
//We may occasionaly raiseToSteal on the river with a good hand to keep opponenents guessing
if (scaledRaiseToStealEV > scaledRaiseToCallEV && randomGen.NextDouble() > 0.75)
{
decision = 4;
}
}
#endregion
}
else
{
if (currentBettingRound == 1 || //We will slow play on the flop
(playerLastActionCurrentRound == PokerAction.Check && randomGen.NextDouble() < avgOppAggression) || //If we just checked we may continue to slow play this round
(scaledCallCheckEV > 0.25m && checkPossible && !tablePositionLate && randomGen.NextDouble() < 0.6 * avgOppAggression) || //Sensible pot (flop/turn) we're early and it's not yet raised
scaledCallCheckEV > 0.75m && !checkPossible && additionalCallAmount > 0.25m * currentPotAmount) //Big pot (flop/turn) and it's been raised sensibly
{
Debug.WriteLine("Slow playing with my big hit. Will you take the bait?");
if (checkPossible)
{
decision = 1;
}
else
{
decision = 2;
}
}
else
{
Debug.WriteLine("I'm not going to slow play my hit. Raising so that it gets expensive if you want to continue.");
//If we are are not going to slow play then we ofcourse default to raise
decision = 3;
}
}
#endregion
}
else if (probWin > 0.5m)
{
#region ProbableWin
//If both raise EV's are positive and better than just calling/checking
if (scaledRaiseToCallEV > playEVThreshold &&
scaledRaiseToStealEV > playEVThreshold &&
scaledRaiseToCallEV > scaledCallCheckEV &&
scaledRaiseToStealEV > scaledCallCheckEV)
{
//Unraised, we've been aggressive, in an early position, then 40% of the time check
if (checkPossible &&
currentHandOurAggression > 2 &&
scaledCallCheckEV > playEVThreshold &&
tablePositionEarly &&
randomGen.NextDouble() < avgOppAggression)
{
Debug.WriteLine("Early position with OK hand, have already been agressive so checking.");
decision = 1;
}
//Unraised, early position, 15% time we will check
else if (checkPossible &&
scaledCallCheckEV > playEVThreshold &&
randomGen.NextDouble() < avgOppAggression * (double)(1.0m - (probWin * 0.8m))) //higher prob win, less checks
{
Debug.WriteLine("Sometimes I want to check with my OK hand.");
decision = 1;
}
//Before river and raised, if we have been aggressive or due to the random number we may call
else if (!checkPossible &&
scaledCallCheckEV > playEVThreshold &&
(randomGen.NextDouble() < avgOppAggression * 0.75 || currentHandOurAggression > 2 || additionalCallAmount > 0.25m * currentPotAmount))
{
Debug.WriteLine("I have a better hand than you but sometimes I will just call to be annoying.");
decision = 2;
}
//If we have not checked or called then we will generally be raising
else if ((randomGen.NextDouble() < 0.8 && scaledRaiseToCallEV > scaledRaiseToStealEV) || //If raiseToCall is best 80% of the time we raiseToCall
(randomGen.NextDouble() < 0.2 && scaledRaiseToStealEV > scaledRaiseToCallEV) || //If raiseToSteal is best 20% of the time we raiseToCall
(probAllOpponentFoldRaiseToSteal >= 0.75m) || //Probability everyone will fold if we try to steal is high enough
currentPotAmount > 40 * currentDecision.Cache.BigBlind) //The pot is already large, a steal is probably pointless
{
//Generally the raise will be to call
Debug.WriteLine("Considered checking/calling with an OK hand but TBH i'm going to raise to call.");
decision = 3;
}
else
{
Debug.WriteLine("Considered checking/calling with an OK hand but TBH i'm going to raise to steal.");
//If we made it to raising but for some reason we didnt raise to call then a steal it is
decision = 4;
}
}
else if (scaledCallCheckEV > playEVThreshold)
{
Debug.WriteLine("Raising doesn't really work for me so i'm just going to call/check.");
if (checkPossible)
{
decision = 1;
}
else
{
decision = 2;
}
}
#endregion
}
else if (probWin > 0.1m)
{
#region DangerArea
//We will consider a steal if it looks favourable
if (scaledRaiseToStealEV > playEVThreshold &&
scaledRaiseToStealEV > scaledCallCheckEV &&
scaledRaiseToStealEV > scaledRaiseToCallEV &&
probAllOpponentFoldRaiseToSteal > 0.75m &&
currentPotAmount <= 40 * currentDecision.Cache.BigBlind)
{
Debug.WriteLine("My hand is not great but I think I can steal it from you, haha.");
decision = 4;
}
else
{
//First action on river with a small pot, finite chance of raising anyway
if (currentBettingRound == 3 &&
playerLastActionCurrentRound == PokerAction.NoAction &&
randomGen.NextDouble() < 0.10 &&
scaledRaiseToCallEV > playEVThreshold &&
currentPotAmount < 12 * currentDecision.Cache.BigBlind)
{
Debug.WriteLine("My hand is not great but I fancy semi bluffing and faking strength.");
if (randomGen.NextDouble() > (double)probAllOpponentFoldRaiseToSteal || scaledRaiseToCallEV > scaledRaiseToStealEV)
{
decision = 3;
}
else
{
decision = 4;
}
}
//Tried to check but got raised a small amount
else if (playerLastActionCurrentRound == PokerAction.Check &&
randomGen.NextDouble() < avgOppAggression * 0.2 &&
scaledRaiseToCallEV > playEVThreshold &&
(currentRoundMinPlayCallAmount * 10.0m <= currentPotAmount || currentRoundMinPlayCallAmount <= currentDecision.Cache.BigBlind * 1.2m))
{
decision = 3;
Debug.WriteLine("Hahahaha, if you're going to raise so little can you handle my check-raise bluff??");
}
else if (scaledCallCheckEV > playEVThreshold)
{
if (checkPossible)
{
Debug.WriteLine("MY hand is not great so i'm checking for some free cards.");
decision = 1;
}
else
{
Debug.WriteLine("I'll call but only because i fancy my draws.");
decision = 2;
}
}
else
{
Debug.WriteLine("I just don't fancy my draws, folding is probably best for me.");
decision = 0;
}
}
#endregion
}
else
{
#region BigFatMiss Or Big Opponent Hit
if (currentBettingRound == 3 &&
(playerLastActionCurrentRound == PokerAction.NoAction || playerLastActionCurrentRound == PokerAction.Check) &&
currentPotAmount < 12 * currentDecision.Cache.BigBlind &&
//Depending on the amount raised and the opponent aggression we may try to bluff
randomGen.NextDouble() < 0.02 * avgOppAggression * (double)(additionalCallAmount > 0 ? (currentPotAmount - additionalCallAmount) / additionalCallAmount : 5))
{
Debug.WriteLine("I have so totally missed, but against my better judgement i'm going to bluff once on the river.");
if (randomGen.NextDouble() > (double)probAllOpponentFoldRaiseToSteal)
{
decision = 3;
}
else
{
decision = 4;
}
}
else
{
//We are not going to attempt to steal if we are beat
if (scaledCallCheckEV > playEVThreshold)
{
Debug.WriteLine("I have so totally missed, but my EV says YES!");
if (checkPossible)
{
decision = 1;
}
else
{
decision = 2;
}
}
else
{
Debug.WriteLine("Fair play, you can have this one, AHOLE!");
decision = 0;
}
}
#endregion
}
#endregion
}
//If we are pot committed we must call anything from here on out
if (potCommitted && !checkPossible && probWin > 0.01m)
{
decision = 2;
}
if (decision == 0)
{
return(new Play(PokerAction.Fold, 0, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0));
}
else if (decision == 1)
{
return(new Play(PokerAction.Check, 0, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0));
}
else if (decision == 2)
{
return(new Play(PokerAction.Call, additionalCallAmount, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0));
}
else if (decision == 3)
{
return(new Play(PokerAction.Raise, raiseToCallAmountNew, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0));
}
else if (decision == 4)
{
return(new Play(PokerAction.Raise, raiseToStealAmountNew, 0, currentDecision.Cache.getCurrentHandId(), currentDecision.PlayerId, decisionLogStr, 0));
}
else
{
throw new Exception("decision value not valid.");
}
}
