private double ComputeBroughtQuality(IList <Card> tableCards, IList <Card> set)
{
var tableCardsScore = Math.Log10(_combinationEvaluator.EvaluateCards(tableCards.ToList()).Score);
var setCardsScore = Math.Log10(_combinationEvaluator.EvaluateCards(set.ToList()).Score);
var scoreDiff = setCardsScore - tableCardsScore;
var scoraRange = _scoreRanges.Single(range => range.CardsCount == 5);
var quality = Math.Round((scoreDiff) / (scoraRange.Max - scoraRange.Min), 3);
return(quality);
}
public void ScoreRangeCalculator()
{
int simulationCount = 500000;
var scoreResults = new Dictionary <int, IList <double> >();
var scoreRanges = new List <ScoreRange>();
var deck = new Deck();
var cards = new List <Card>();
var hand = new List <Card>();
for (int i = 3; i < 4; i++)
{
var numberOfCards = i + 2;
scoreResults.Add(numberOfCards, new List <double>());
for (int u = 0; u < simulationCount; u++)
{
deck.Regroup();
deck.Shuffle();
cards.Clear();
hand.Clear();
for (int j = 0; j < numberOfCards; j++)
{
cards.Add(deck.Draw());
}
var cardCombination = _combinationEvaluator.EvaluateCards(cards);
scoreResults[numberOfCards].Add(cardCombination.Score);
}
}
var str = String.Join("\n", scoreResults.Values.First().ToList().OrderBy(v => v).Select(v => v.ToString()));
//foreach (var keyValuePair in scoreResults.ToList())
//{
// var max = keyValuePair.Value.OrderByDescending(v => v).First();
// var min = keyValuePair.Value.OrderByDescending(v => v).Last();
// scoreRanges.Add(new ScoreRange(keyValuePair.Key, min, max));
//}
var logPath = System.IO.Path.GetTempFileName();
var logFile = System.IO.File.Create(logPath);
var logWriter = new System.IO.StreamWriter(logFile);
logWriter.WriteLine(str);
logWriter.Dispose();
}
public override PlayerAction Play(IList <PlayerAction> actions)
{
var maxBid = Table.Players.Max(player => player.Bid);
var debtRatio = maxBid / (Player.Cash + Player.Bid);
var combination = _combinationEvaluator.EvaluateCards(new List <Card> {
Player.Hand.Card1, Player.Hand.Card2
});
if (debtRatio > 0.5 && combination.Score >= 200)
{
return(new PlayerAction(Player, PlayerState.AllIn, 0, 0,
actions.Single(action => action.State == PlayerState.AllIn).Amount));
}
if (debtRatio > 0.5)
{
return(new PlayerAction(Player, PlayerState.Fold, 0, 0));
}
if (debtRatio <= 0.2)
{
if (actions.Any(action => action.State == PlayerState.Call))
{
return(new PlayerAction(Player, PlayerState.Call, 0, 0,
actions.Single(action => action.State == PlayerState.Call).Amount));
}
else if (actions.Any(action => action.State == PlayerState.Bet))
{
return(new PlayerAction(Player, PlayerState.Bet, 0, 0,
actions.Single(action => action.State == PlayerState.Bet).Lower *2));
}
}
return(new PlayerAction(Player, PlayerState.Fold, 0, 0));
}
private void ResolvePots()
{
if (Players.Count(player => player.State != PlayerState.Fold) == 1)
{
var playerToWin = Players.Single(player => player.State != PlayerState.Fold);
var winner = new List <KeyValuePair <Player, CardCombination> >()
{
new KeyValuePair <Player, CardCombination>(playerToWin, null)
};
foreach (var pot in Pots)
{
pot.DeclareWinners(winner);
_notifier.PlayersWinPots(winner, pot);
}
}
else
{
foreach (var pot in Pots)
{
var results = new Dictionary <Player, CardCombination>();
foreach (var player in pot.Participants)
{
var playerCardsCombination = new List <Card>()
{
player.Hand.Card1,
player.Hand.Card2,
};
playerCardsCombination = playerCardsCombination.Concat(Cards.Cards).ToList();
results.Add(player, _combinationEvaluator.EvaluateCards(playerCardsCombination));
}
var resultList = results.OrderByDescending(result => result.Value.Score).ToList();
var winners = new List <KeyValuePair <Player, CardCombination> >();
winners.Add(resultList[0]);
if (results.Count > 1)
{
for (int i = 1; i < results.Count; i++)
{
if (resultList[i].Value.Score == resultList[0].Value.Score)
{
winners.Add(resultList[i]);
}
}
}
pot.DeclareWinners(winners);
_notifier.PlayersWinPots(winners, pot);
}
}
}
public override PlayerAction Play(IList <PlayerAction> actions)
{
var combination = _combinationEvaluator.EvaluateCards(new List <Card> {
Player.Hand.Card1, Player.Hand.Card2
});
if (combination.Score >= 200)
{
return(new PlayerAction(Player, PlayerState.AllIn, 0, 0,
actions.Single(action => action.State == PlayerState.AllIn).Amount));
}
else
{
return(new PlayerAction(Player, PlayerState.Fold, 0, 0));
}
}
public void ShouldEvalRoyalFlush(string str, string expectedCombination)
{
var cards = CardsBuilder.BuildCardsFromString(str);
var combination = _combinationEvaluator.EvaluateCards(cards);
var combinationString = CardsBuilder.BuildStringFromCards(combination.Cards);
Assert.AreEqual(CombinationType.RoyalFlush, combination.Type);
Assert.AreEqual(expectedCombination, combinationString);
}