/// <summary>
/// The name last action in sequence.
/// </summary>
/// <param name="actionSequence">
/// The action sequence.
/// </param>
/// <returns>
/// The name last action in sequence.
/// </returns>
/// <exception cref="NotSupportedException"></exception>
public static string NameLastActionInSequence(ActionSequences actionSequence)
{
if (Folds.Contains(actionSequence))
{
return("Fold");
}
if (Calls.Contains(actionSequence))
{
return("Call");
}
if (Raises.Contains(actionSequence))
{
return("Raise");
}
if (Bets.Contains(actionSequence))
{
return("Bet");
}
if (actionSequence == ActionSequences.HeroX)
{
return("Check");
}
throw new NotSupportedException("Cannot name last action of " + actionSequence);
}
public static IAnalyzablePokerPlayer AnalyzablePokerPlayerWith(long id, ActionSequences actionSequence, Streets street, StrategicPositions strategicPosition)
{
var analyzablePokerPlayer = (AnalyzablePokerPlayer)AnalyzablePokerPlayerWith(id, actionSequence, street, false);
analyzablePokerPlayer.StrategicPosition = strategicPosition;
return(analyzablePokerPlayer);
}
public AnalyzablePokerPlayer()
{
InPosition = new bool?[(int)(Streets.River + 1)];
ActionSequences = new ActionSequences[(int)(Streets.River + 1)];
BetSizeIndexes = new int[(int)(Streets.River + 1)];
_sequenceStrings = new string[(int)(Streets.River + 1)];
}
public override string ToString()
{
var sb =
new StringBuilder(
string.Format(
"Id: {0}, BB: {1}, Ante: {2}, TimeStamp: {3}, TotalPlayers: {4}, HandId: {5}, MBefore: {6}, Position: {7}, StrategicPosition: {8}, Holecards: {9}",
Id,
BB,
Ante,
TimeStamp,
TotalPlayers,
HandId,
MBefore,
Position,
StrategicPosition,
Holecards));
sb.AppendLine("\nInPosition");
InPosition.ToList().ForEach(sp => sb.Append(sp.ToString() + " "));
sb.AppendLine("\nActionSequences");
ActionSequences.ToList().ForEach(seq => sb.Append(seq.ToString() + " "));
sb.AppendLine("\nBetSizeIndexes");
BetSizeIndexes.ToList().ForEach(bs => sb.Append(bs.ToString() + " "));
sb.AppendLine("\nSequences");
Sequences.ToList().ForEach(seq => sb.Append(seq.ToStringNullSafe() + "\n"));
return(sb.ToString());
}
/// <summary>
/// The get last action in.
/// </summary>
/// <param name="actionSequence">
/// The action sequence.
/// </param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
public static ActionTypes GetLastActionIn(ActionSequences actionSequence)
{
if (Folds.Contains(actionSequence))
{
return(ActionTypes.F);
}
if (Calls.Contains(actionSequence))
{
return(ActionTypes.C);
}
if (Raises.Contains(actionSequence))
{
return(ActionTypes.R);
}
if (Checks.Contains(actionSequence))
{
return(ActionTypes.X);
}
if (Bets.Contains(actionSequence))
{
return(ActionTypes.B);
}
throw new ArgumentException(actionSequence + " has no last Action");
}
static string DescribeAction(ActionSequences actionSequence)
{
string possibleCheck = ActionSequencesUtility.GetHeroChecksThenReacts.Contains(actionSequence)
? ActionTypesUtility.Name(ActionTypes.X).ToLower() + "-"
: string.Empty;
return(possibleCheck + ActionSequencesUtility.NamePastTenseOfLastActionSequence(actionSequence) +
" a " + ActionTypesUtility.Name(ActionTypes.B).ToLower());
}
protected override IActionSequenceStatisticsSet NewActionSequenceSetStatistics(
IPercentagesCalculator percentagesCalculator,
IEnumerable <IActionSequenceStatistic> statistics,
string playerName,
Streets street,
ActionSequences actionSequence,
bool inPosition)
{
return(_stub.Out <IActionSequenceStatisticsSet>());
}
public void PrepareAnalyzationFor_PreFlopUnraisedPotAndFirstMatchingHeroActionIsAtIndexOne_StartingActionIndexIsOne(
[Values("[1]C,[2]F,[3]C", "[1]C,[2]C,[3]C", "[1]C,[2]R,[3]C")] string sequenceString,
[Values(ActionSequences.HeroF, ActionSequences.HeroC, ActionSequences.HeroR)] ActionSequences actionSequence)
{
IConvertedPokerRound sequence = sequenceString.ToConvertedPokerRoundWithIds();
_sut.PrepareAnalyzationFor(sequence, HeroPosition, actionSequence);
_sut.StartingActionIndex.ShouldBeEqualTo(1);
}
public void PrepareAnalyzationFor_FlopHeroXOppBAndFirstMatchingHeroReactionIsAtIndexTwo_StartingActionIndexIsTwo(
[Values("[2]X,[1]B,[2]F", "[2]X,[1]B,[2]C", "[2]X,[1]B,[2]R")] string sequenceString,
[Values(ActionSequences.HeroXOppBHeroF, ActionSequences.HeroXOppBHeroC, ActionSequences.HeroXOppBHeroR)] ActionSequences actionSequence)
{
IConvertedPokerRound sequence = sequenceString.ToConvertedPokerRoundWithIds();
_sut.PrepareAnalyzationFor(sequence, HeroPosition, actionSequence);
_sut.StartingActionIndex.ShouldBeEqualTo(2);
}
protected virtual IActionSequenceStatisticsSet NewActionSequenceSetStatistics(
IPercentagesCalculator percentagesCalculator,
IEnumerable <IActionSequenceStatistic> statistics,
string playerName,
Streets street,
ActionSequences actionSequence,
bool inPosition)
{
return(new ActionSequenceStatisticsSet(percentagesCalculator, statistics, playerName, street, actionSequence, inPosition));
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionSequenceStatisticsSet"/> class.
/// Creates instance of ActionSequenceStatisticsSet.
/// Use for PreFlop Statistics only
/// </summary>
/// <param name="percentagesCalculator">
/// </param>
/// <param name="statistics">
/// </param>
/// <param name="playerName">
/// <see cref="IActionSequenceStatisticsSet.PlayerName"/>
/// </param>
/// <param name="actionSequence">
/// <see cref="IActionSequenceStatisticsSet.ActionSequence"/>
/// </param>
/// <param name="raisedPot">
/// <see cref="IActionSequenceStatisticsSet.RaisedPot"/>
/// </param>
public ActionSequenceStatisticsSet(
IPercentagesCalculator percentagesCalculator,
IEnumerable <IActionSequenceStatistic> statistics,
string playerName,
ActionSequences actionSequence,
bool raisedPot)
: this(percentagesCalculator, statistics, playerName, Streets.PreFlop, actionSequence, false)
{
RaisedPot = raisedPot;
}
public string Describe(string playerName, IAnalyzablePokerPlayer analyzablePokerPlayer, Streets street, ITuple <double, double> ratioSizes)
{
ActionSequences actionSequence = analyzablePokerPlayer.ActionSequences[(int)street];
return(string.Format("{0} {1} ({2} of the pot), when {3} on the {4}, and was reraised",
playerName,
DescribeAction(actionSequence),
PostFlopRaiseReactionDescriberUtils.DescribeBetSizes(ratioSizes),
StatisticsDescriberUtils.DescribePosition(analyzablePokerPlayer, street),
street.ToString().ToLower()));
}
public static string NamePastTenseOfLastActionSequence(ActionSequences actionSequence)
{
ActionTypes lastAction = GetLastActionIn(actionSequence);
return
(lastAction.Match()
.With(a => a == ActionTypes.F, _ => "folded")
.With(a => a == ActionTypes.C, _ => "called")
.With(a => a == ActionTypes.R, _ => "raised")
.Do());
}
public string Hint(string playerName, ActionSequences actionSequence, bool inPosition)
{
var sb = new StringBuilder(string.Format("The table shows how {0} acted when sitting in a certain position at the table.", playerName));
if (actionSequence == ActionSequences.PreFlopNoFrontRaise)
{
sb.AppendLine("A check from the big blind is counted as a fold.");
}
return(sb.ToString());
}
internal static IAnalyzablePokerPlayer AnalyzablePokerPlayerWith(long id, ActionSequences actionSequence, Streets street, bool inPosition, int betSizeIndex)
{
IAnalyzablePokerPlayer analyzablePokerPlayer = new AnalyzablePokerPlayer {
Id = id
};
analyzablePokerPlayer.ActionSequences[(int)street] = actionSequence;
analyzablePokerPlayer.InPosition[(int)street] = inPosition;
analyzablePokerPlayer.BetSizeIndexes[(int)street] = betSizeIndex;
return(analyzablePokerPlayer);
}
bool FoundMatchFor(string pattern, ActionSequences actionSequence)
{
Match match = Regex.Match(_sequenceString, pattern, RegexOptions.IgnoreCase);
if (match.Success)
{
ActionSequence = actionSequence;
BetSizeIndex = StandardizedBetSizes.IndexOf(System.Convert.ToInt32(match.Groups["BetSizeKey"].Value));
return(true);
}
return(false);
}
protected ActionSequenceStatistic(ActionSequences actionSequence, Streets street, int indexesCount)
{
_actionSequence = actionSequence;
_street = street;
Percentages = new int[indexesCount];
MatchingPlayers = new List <IAnalyzablePokerPlayer> [indexesCount];
for (int i = 0; i < MatchingPlayers.Length; i++)
{
MatchingPlayers[i] = new List <IAnalyzablePokerPlayer>();
}
}
double[] SelectRatioAccordingTo(ActionSequences actionSequence)
{
switch (actionSequence)
{
case ActionSequences.HeroC:
return(_unraisedPotCallingRatios);
case ActionSequences.OppRHeroC:
return(_raisedPotCallingRatios);
default:
return(_raiseSizeKeys);
}
}
void PrepareAnalyzation(ActionSequences actionSequence)
{
try
{
SetStartingActionIndex(actionSequence);
WasSuccessful = true;
}
catch (Exception excep)
{
Log.Error(excep);
WasSuccessful = false;
}
}
public void AnalyzeUsingDataFrom_OnlyOneOpponentRaisedAndMoreActionsAfterHerosReaction_IsStandardSituationIsTrue(
[Values("[2]B,[1]R3.0,[2]F,[4]R2.0", "[1]B,[2]R,[1]R3.0,[2]F,[4]R2.0", "[2]X,[1]B,[2]R,[1]R3.0,[2]F,[4]R2.0"
)] string sequenceString,
[Values(ActionSequences.HeroB, ActionSequences.OppBHeroR, ActionSequences.HeroXOppBHeroR)] ActionSequences
actionSequence)
{
IConvertedPokerRound sequence = sequenceString.ToConvertedPokerRoundWithIds();
_analyzationPreparer.PrepareAnalyzationFor(sequence, HeroPosition, actionSequence);
_sut.AnalyzeUsingDataFrom(_stub.Out <IAnalyzablePokerPlayer>(), _analyzationPreparer, true, _raiseSizes);
_sut.IsStandardSituation.ShouldBeTrue();
}
public void SelectedActionSequence_OneCellWithOppBHeroRDataSelected_ReturnsOppBHeroR()
{
const ActionSequences actionSequence = ActionSequences.OppBHeroR;
var statisticStub = _stub.Setup <IActionSequenceStatistic>()
.Get(s => s._actionSequence).Returns(actionSequence)
.Out;
var statisticSetStub = _stub.Setup <IActionSequenceStatisticsSet>()
.Get(s => s.ActionSequenceStatistics).Returns(new[] { statisticStub })
.Out;
_sut.InitializeWith(statisticSetStub)
.AddToSelection(0, 0);
_sut.SelectedActionSequence.ShouldBeEqualTo(actionSequence);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionSequenceStatisticsSet"/> class.
/// Creates instance of ActionSequenceStatisticsSet.
/// Use for PostFlop Statistics only
/// </summary>
/// <param name="percentagesCalculator">
/// </param>
/// <param name="statistics">
/// </param>
/// <param name="playerName">
/// <see cref="IActionSequenceStatisticsSet.PlayerName"/>
/// </param>
/// <param name="street">
/// <see cref="IActionSequenceStatisticsSet.Street"/>
/// </param>
/// <param name="actionSequence">
/// <see cref="IActionSequenceStatisticsSet.ActionSequence"/>
/// </param>
/// <param name="inPosition">
/// <see cref="IActionSequenceStatisticsSet.InPosition"/>
/// </param>
public ActionSequenceStatisticsSet(
IPercentagesCalculator percentagesCalculator,
IEnumerable <IActionSequenceStatistic> statistics,
string playerName,
Streets street,
ActionSequences actionSequence,
bool inPosition)
{
_percentagesCalculator = percentagesCalculator;
_statistics = statistics;
ActionSequence = actionSequence;
PlayerName = playerName;
Street = street;
InPosition = inPosition;
}
public IPreFlopHandStrengthStatistics BuildStatisticsFor(
IEnumerable <IAnalyzablePokerPlayer> analyzablePokerPlayers, ActionSequences actionSequence)
{
RatiosUsed = SelectRatioAccordingTo(actionSequence);
AnalyzablePlayersWithKnownCards =
analyzablePokerPlayers.Where(p => !string.IsNullOrEmpty(p.Holecards) && !p.Holecards.Contains('?'));
SortAnalyzablePlayersWithKnownCardsByColumn();
ExtractAndValueTheirHoleCards();
DetermineAverageChenValuesAndSklanskyMalmuthGroupings();
return(this);
}
public void UpdateWith_OneMatchingPlayer_MatchingPlayersForOtherPositionDoNotContainPlayer()
{
const long id = 1;
const Streets street = Streets.PreFlop;
const ActionSequences actionSequence = ActionSequences.HeroC;
const StrategicPositions position = StrategicPositions.CO;
_sut = new PreFlopActionSequenceStatistic(actionSequence);
var player = Samples.AnalyzablePokerPlayerWith(id, actionSequence, street, position);
_analyzablePokerPlayers.Add(player);
_sut.UpdateWith(_analyzablePokerPlayers);
_sut.MatchingPlayers[(int)position + 1].ShouldNotContain(player);
}
public void UpdateWith_PlayerWithHeroXOppBHeroReacts_PlayerIsIncludedInMatchingPlayers(
[Values(ActionSequences.HeroXOppBHeroF, ActionSequences.HeroXOppBHeroC, ActionSequences.HeroXOppBHeroR)]
ActionSequences actionSequence)
{
const long id = 1;
const bool inPosition = false;
const Streets street = Streets.Flop;
var sut = new PostFlopHeroXStatistic(street, inPosition);
var player = Samples.AnalyzablePokerPlayerWith(id, actionSequence, street, inPosition);
_analyzablePokerPlayers.Add(player);
sut.UpdateWith(_analyzablePokerPlayers);
sut.MatchingPlayers[0].ShouldContain(player);
}
public void UpdateWith_OneMatchingPlayer_MatchingPlayersForOtherBetSizeDoNotContainPlayer()
{
const long id = 1;
const bool inPosition = false;
const Streets street = Streets.Flop;
const ActionSequences actionSequence = ActionSequences.OppBHeroC;
const int betSizeIndex = 1;
_sut = new PostFlopActionSequenceStatistic(actionSequence, street, inPosition, indexesCount);
var player = Samples.AnalyzablePokerPlayerWith(id, actionSequence, street, inPosition, betSizeIndex);
_analyzablePokerPlayers.Add(player);
_sut.UpdateWith(_analyzablePokerPlayers);
_sut.MatchingPlayers[betSizeIndex + 1].ShouldNotContain(player);
}
public void UpdateWith_TwoPlayersOneMatchingPlayer_MatchingPlayersForGivenPositionContainMatchingPlayer()
{
const long id = 1;
const Streets street = Streets.PreFlop;
const ActionSequences actionSequence = ActionSequences.HeroC;
const StrategicPositions position = StrategicPositions.CO;
_sut = new PreFlopActionSequenceStatistic(actionSequence);
var matchingPlayer = Samples.AnalyzablePokerPlayerWith(id, actionSequence, street, position);
var notMatchingPlayer = Samples.AnalyzablePokerPlayerWith(id + 1, actionSequence + 1, street, position);
_analyzablePokerPlayers.Add(matchingPlayer);
_analyzablePokerPlayers.Add(notMatchingPlayer);
_sut.UpdateWith(_analyzablePokerPlayers);
_sut.MatchingPlayers[(int)position].ShouldContain(matchingPlayer);
}
public IRaiseReactionStatistics Build(
IEnumerable <IAnalyzablePokerPlayer> analyzablePokerPlayers,
ActionSequences actionSequence,
Streets street,
bool considerOpponentsRaiseSize)
{
if (analyzablePokerPlayers.Count() < 1)
{
throw new ArgumentException("need at least one analyzable player");
}
analyzablePokerPlayers.ForEach(
analyzablePlayer => _raiseReactionsAnalyzer.AnalyzeAndAdd(_raiseReactionAnalyzerMake.New,
analyzablePlayer,
street,
actionSequence,
considerOpponentsRaiseSize));
return(_raiseReactionStatistics.InitializeWith(_raiseReactionsAnalyzer));
}
public void UpdateWith_TwoPlayersOneMatchingPlayer_MatchingPlayersForGivenBetSizeContainMatchingPlayer()
{
const long id = 1;
const bool inPosition = false;
const Streets street = Streets.Flop;
const ActionSequences actionSequence = ActionSequences.OppBHeroC;
const int betSizeIndex = 1;
_sut = new PostFlopActionSequenceStatistic(actionSequence, street, inPosition, indexesCount);
var matchingPlayer = Samples.AnalyzablePokerPlayerWith(id, actionSequence, street, inPosition, betSizeIndex);
var notMatchingPlayer = Samples.AnalyzablePokerPlayerWith(id + 1, actionSequence + 1, street, inPosition, betSizeIndex);
_analyzablePokerPlayers.Add(matchingPlayer);
_analyzablePokerPlayers.Add(notMatchingPlayer);
_sut.UpdateWith(_analyzablePokerPlayers);
_sut.MatchingPlayers[betSizeIndex].ShouldContain(matchingPlayer);
}
void SetStartingActionIndex(ActionSequences actionSequence)
{
ActionTypes actionToLookFor = ActionSequencesUtility.GetLastActionIn(actionSequence);
IEnumerable <IConvertedPokerActionWithId> foundAction
= from IConvertedPokerActionWithId action in Sequence
where
action.What.Equals(actionToLookFor) &&
action.Id.Equals(HeroPosition)
select action;
if (foundAction.Count() > 0)
{
StartingActionIndex = Sequence.Actions.IndexOf(foundAction.First());
}
else
{
throw new ArgumentException("Couldn't find action: " + actionToLookFor);
}
}
