public static int RateCards(IEnumerable <Card> cards)
{
var evaluator = new HandEvaluator();
var strength = (int)evaluator.GetBestHand(cards).RankType;
return(strength);
}
public static int RateCards(IEnumerable<Card> cards)
{
var evaluator = new HandEvaluator();
var strength = (int)evaluator.GetBestHand(cards).RankType;
return strength;
}
public void GetRankTypeShouldWorkCorrectly(ICollection <Card> playerCards, HandRankType expectedHandRankType, ICollection <CardType> expectedBestHandCards)
{
IHandEvaluator handEvaluator = new HandEvaluator();
var bestHand = handEvaluator.GetBestHand(playerCards.Shuffle().ToList());
Assert.Equal(expectedHandRankType, bestHand.RankType);
CollectionsAssert.SameElements(expectedBestHandCards, bestHand.Cards);
}
/// <summary>
/// Claculates current CardValuation type based on players cards and community cards
/// </summary>
/// <param name="firstCard">first cards</param>
/// <param name="secondCard">second card</param>
/// <param name="comunityCards">Comunity cards</param>
/// <returns>the Card Valuation Type</returns>
public static CardValuationType Flop(Card firstCard, Card secondCard, IEnumerable<Card> comunityCards)
{
var handEvaluator = new HandEvaluator();
var cards = new List<Card>();
cards.AddRange(comunityCards);
var playerCards = new List<Card>();
playerCards.Add(firstCard);
playerCards.Add(secondCard);
var percentageValuation = new PercentageValuation();
var percentage = percentageValuation.CalculatePercentage(playerCards, cards);
cards.Add(firstCard);
cards.Add(secondCard);
var bestHand = handEvaluator.GetBestHand(cards);
if (bestHand.RankType >= Logic.HandRankType.FourOfAKind)
{
return CardValuationType.PlayItAllIn;
}
if (bestHand.RankType >= Logic.HandRankType.ThreeOfAKind)
{
return CardValuationType.Recommended;
}
if (percentage < 25)
{
return CardValuationType.Unplayable;
}
if (percentage < 45)
{
return CardValuationType.Risky;
}
if (percentage < 85)
{
return CardValuationType.Recommended;
}
return CardValuationType.StronglyRecommended;
}
/// <summary>
/// Claculates current CardValuation type based on players cards and community cards
/// </summary>
/// <param name="firstCard">first cards</param>
/// <param name="secondCard">second card</param>
/// <param name="comunityCards">Comunity cards</param>
/// <returns>the Card Valuation Type</returns>
public static CardValuationType River(Card firstCard, Card secondCard, IEnumerable<Card> comunityCards)
{
var handEvaluator = new HandEvaluator();
var cards = new List<Card>();
cards.AddRange(comunityCards);
cards.Add(firstCard);
cards.Add(secondCard);
var bestHand = handEvaluator.GetBestHand(cards);
if (bestHand.RankType <= Logic.HandRankType.Pair)
{
return CardValuationType.Unplayable;
}
if (bestHand.RankType <= Logic.HandRankType.TwoPairs)
{
return CardValuationType.Risky;
}
if (bestHand.RankType > Logic.HandRankType.TwoPairs && bestHand.RankType <= Logic.HandRankType.Straight)
{
return CardValuationType.Recommended;
}
if (bestHand.RankType > Logic.HandRankType.Flush)
{
return CardValuationType.StronglyRecommended;
}
return CardValuationType.StronglyRecommended;
}
/// <summary>
/// Calculates percesentage for the currant hand in the game;
/// </summary>
/// <param name="playerCards">The Turing player cards</param>
/// <param name="cards">Community cards</param>
/// <returns>Percentage for game development in Turing's favour</returns>
public double CalculatePercentage(IEnumerable<Card> playerCards, IEnumerable<Card> cards)
{
var deck = new List<Card>();
for (int i = 0; i <= 3; i++)
{
for (int j = 2; j <= 14; j++)
{
deck.Add(new Card((CardSuit)i, (CardType)j));
}
}
List<Card[]> pairsCombos = new List<Card[]>();
for (int i = 0; i < deck.Count; i++)
{
for (int j = 0; j < deck.Count; j++)
{
if (i != j)
{
pairsCombos.Add(new Card[2] { deck[i], deck[j] });
}
}
}
HashSet<Card> board = new HashSet<Card>(cards);
var handEvaluator = new HandEvaluator();
var myPlayerCards = new HashSet<Card>();
foreach (var card in playerCards)
{
myPlayerCards.Add(card);
}
foreach (var card in board)
{
myPlayerCards.Add(card);
}
var playerBestHand = handEvaluator.GetBestHand(myPlayerCards);
long wins = 0, ties = 0, loses = 0, count = 0;
for (var i = 0; i < 1; i++)
{
var otherHand = new HashSet<Card>();
foreach (var pairsCombo in pairsCombos)
{
foreach (var card in pairsCombo)
{
otherHand.Add(card);
}
foreach (var card in board)
{
otherHand.Add(card);
}
if (otherHand.Count < 5)
{
continue;
}
var otherBestHand = handEvaluator.GetBestHand(otherHand);
if (playerBestHand.RankType > otherBestHand.RankType)
{
wins++;
}
else if (playerBestHand.RankType == otherBestHand.RankType)
{
ties++;
}
else
{
loses++;
}
count++;
otherHand.Clear();
}
}
var percent = (((double)wins) + (((double)ties) / 2.0)) / ((double)count) * 100.0;
return percent;
}
public double CalculateOuts(IEnumerable<Card> playerCards, IEnumerable<Card> cards)
{
var deck = new List<Card>();
for (int i = 0; i <= 3; i++)
{
for (int j = 2; j <= 14; j++)
{
deck.Add(new Card((CardSuit)i, (CardType)j));
}
}
List<Card[]> pairsCombos = new List<Card[]>();
for (int i = 0; i < deck.Count; i++)
{
for (int j = 0; j < deck.Count; j++)
{
if (i != j)
{
pairsCombos.Add(new Card[2] { deck[i], deck[j] });
}
}
}
HashSet<Card> board = new HashSet<Card>(cards);
var handEvaluator = new HandEvaluator();
var myPlayerCards = new HashSet<Card>();
foreach (var card in playerCards)
{
myPlayerCards.Add(card);
}
foreach (var card in board)
{
myPlayerCards.Add(card);
}
var handEvaluatorExtended = new HandEvaluatorExtension();
var bestHandFromBoard = handEvaluatorExtended.GetBestHandForFlop(board);
var playerBestHand = handEvaluator.GetBestHand(myPlayerCards);
if (playerBestHand.RankType <= bestHandFromBoard.RankType &&
(cards.ToList().Count() == 3))
{
return 21;
}
if (cards.Count() == 4 && cards.Any())
{
var bestHandFromBoardOnTurn = handEvaluatorExtended.GetBestHandForTurn(board);
if (playerBestHand.RankType <= bestHandFromBoardOnTurn.RankType)
{
return 21;
}
}
long wins = 0, ties = 0, loses = 0, count = 0;
// Iterate through all possible opponent hole cards
// This is one because it is very slow otherwise.
// I have tested it and there is not much of a difference
for (var i = 0; i < 1; i++)
{
var otherHand = new HashSet<Card>();
foreach (var pairsCombo in pairsCombos)
{
foreach (var card in pairsCombo)
{
otherHand.Add(card);
}
foreach (var card in board)
{
otherHand.Add(card);
}
if (otherHand.Count < 5)
{
continue;
}
var otherBestHand = handEvaluator.GetBestHand(otherHand);
if (playerBestHand.RankType > otherBestHand.RankType)
{
wins++;
}
else if (playerBestHand.RankType == otherBestHand.RankType)
{
ties++;
}
else
{
loses++;
}
count++;
otherHand.Clear();
}
}
var percent = (((double)wins) + ((double)ties) / 2.0) / ((double)count) * 100.0;
return percent;
}
public override async Task RunAsync()
{
this.Started = true;
DiscordMessage msg = await this.Channel.EmbedAsync("Starting Hold'Em game... Keep an eye on DM!");
foreach (HoldemParticipant participant in this.Participants)
{
participant.Card1 = this.deck.GetNextCard();
participant.Card2 = this.deck.GetNextCard();
try {
participant.DmHandle = await participant.DmHandle.ModifyAsync($"Your hand: {participant.Card1.ToUserFriendlyString()} {participant.Card2.ToUserFriendlyString()}");
} catch {
}
}
await Task.Delay(TimeSpan.FromSeconds(10));
this.drawn.AddRange(this.deck.DrawCards(3));
int bet = 5;
for (int step = 0; step < 2; step++)
{
foreach (HoldemParticipant participant in this.ActiveParticipants)
{
participant.Bet = 0;
}
while (this.ActiveParticipants.Any(p => p.Bet != bet))
{
foreach (HoldemParticipant participant in this.ActiveParticipants)
{
await this.PrintGameAsync(msg, bet, participant);
if (await this.Interactivity.WaitForBoolReplyAsync(this.Channel.Id, participant.Id))
{
await this.Channel.SendMessageAsync($"Do you wish to raise the current bet? If yes, reply yes and then reply raise amount in new message, otherwise say no. Max: {participant.Balance - bet}");
if (await this.Interactivity.WaitForBoolReplyAsync(this.Channel.Id, participant.Id))
{
int raise = 0;
MessageContext mctx = await this.Interactivity.WaitForMessageAsync(
m => m.Channel.Id == this.Channel.Id && m.Author.Id == participant.Id && int.TryParse(m.Content, out raise) && bet + raise <= participant.Balance
);
if (mctx != null)
{
bet += raise;
}
}
participant.Balance -= bet - participant.Bet;
participant.Bet = bet;
this.Pot += bet;
}
else
{
participant.Folded = true;
}
}
}
this.drawn.Add(this.deck.GetNextCard());
}
this.GameOver = true;
await this.PrintGameAsync(msg, bet, showhands : true);
foreach (HoldemParticipant p in this.ActiveParticipants)
{
p.HandRank = _evaluator.GetBestHand(new List <Card>(this.drawn)
{
p.Card1, p.Card2
}).RankType;
}
var winner = this.Participants.OrderByDescending(p => p.HandRank).FirstOrDefault();
if (winner != null)
{
winner.Balance += this.Pot;
}
this.Winner = winner?.User;
}
public static CardValuationType Turn(Card firstCard, Card secondCard, IEnumerable<Card> comunityCards)
{
var handEvaluator = new HandEvaluator();
var cards = new List<Card>();
cards.AddRange(comunityCards);
var playerCards = new List<Card>();
playerCards.Add(firstCard);
playerCards.Add(secondCard);
//var bestHand = handEvaluator.GetBestHand(cards);
var outsValuation = new GameOutsValuation();
var outsResult = outsValuation.CalculateOuts(playerCards, cards);
cards.Add(firstCard);
cards.Add(secondCard);
var bestHand = handEvaluator.GetBestHand(cards);
if (bestHand.RankType >= Logic.HandRankType.FourOfAKind)
{
return CardValuationType.PlayItAllIn;
}
if (outsResult < 25)
{
return CardValuationType.Unplayable;
}
if (outsResult < 45)
{
return CardValuationType.Risky;
}
if (outsResult < 85)
{
return CardValuationType.Recommended;
}
return CardValuationType.StronglyRecommended;
}
