public static PokerScoreOuts CalculateRiver(SixCardHand cards)
{
//if there are 4 of the same suit there are 9 more of that suit we can hit
return(cards.CountFlush() == 4
? PokerHelper.CreateRiverOuts(9)
: PokerHelper.CreateRiverOuts(0));
}
public void RemoveThreePairSuited()
{
Stopwatch watch = new Stopwatch();
List <Card> cards = new List <Card>
{
new Card(Rank.Ace, Suit.Hearts),
new Card(Rank.Ace, Suit.Clubs),
new Card(Rank.Six, Suit.Hearts),
new Card(Rank.Six, Suit.Clubs),
new Card(Rank.Queen, Suit.Diamonds),
new Card(Rank.Queen, Suit.Hearts),
};
SixCardHand hand = new SixCardHand(cards);
hand.Sort();
watch.Start();
var newCards = hand.RemovePairs();
watch.Stop();
Assert.AreEqual(3, newCards.Count);
Assert.Greater(25, watch.ElapsedMilliseconds);
Assert.AreEqual(true, newCards[0].Rank == Rank.Six && newCards[0].Suit == Suit.Hearts &&
newCards[1].Rank == Rank.Queen &&
newCards[2].Rank == Rank.Ace && newCards[2].Suit == Suit.Hearts);
}
public void ThreeOfAKindToFour()
{
Stopwatch watch = new Stopwatch();
List <Card> cards = new List <Card>
{
new Card(Rank.Ace, Suit.Hearts),
new Card(Rank.Six, Suit.Diamonds),
new Card(Rank.Five, Suit.Hearts),
new Card(Rank.Six, Suit.Clubs),
new Card(Rank.Six, Suit.Spades),
new Card(Rank.Queen, Suit.Clubs),
};
SixCardHand hand = new SixCardHand(cards);
hand.Sort();
watch.Start();
var current = PokerEvaluator.CalculateTurnScore(hand.Cards);
var outs = PokerOutsCalculator.CalculateRiverOuts(hand, current);
watch.Stop();
Assert.AreEqual(1, outs.FourOfAKind.Outs);
Assert.AreEqual(false, outs.FourOfAKind.RunnerRunner);
Assert.Greater(200, watch.ElapsedMilliseconds);
}
public void OneInsideSFlushHighAce()
{
Stopwatch watch = new Stopwatch();
List <Card> cards = new List <Card>
{
new Card(Rank.Ace, Suit.Hearts),
new Card(Rank.Queen, Suit.Hearts),
new Card(Rank.Five, Suit.Hearts),
new Card(Rank.Jack, Suit.Hearts),
new Card(Rank.Five, Suit.Hearts),
new Card(Rank.Ten, Suit.Hearts),
};
SixCardHand hand = new SixCardHand(cards);
hand.Sort();
watch.Start();
var score = PokerEvaluator.CalculateFlopScore(hand.Cards);
var outs = PokerOutsCalculator.CalculateRiverOuts(hand, score);
watch.Stop();
Assert.AreEqual(1, outs.StraightFlush.Outs);
Assert.Greater(200, watch.ElapsedMilliseconds);
}
public void OneInsideStraightDrawWithHighAceWithTwoPair()
{
Stopwatch watch = new Stopwatch();
List <Card> cards = new List <Card>
{
new Card(Rank.Queen, Suit.Diamonds),
new Card(Rank.King, Suit.Hearts),
new Card(Rank.Ten, Suit.Clubs),
new Card(Rank.Queen, Suit.Spades),
new Card(Rank.King, Suit.Hearts),
new Card(Rank.Ace, Suit.Diamonds),
};
SixCardHand hand = new SixCardHand(cards);
hand.Sort();
watch.Start();
var score = PokerEvaluator.CalculateFlopScore(hand.Cards);
var outs = PokerOutsCalculator.CalculateRiverOuts(hand, score);
watch.Stop();
Assert.AreEqual(4, outs.Straight.Outs);
Assert.Greater(200, watch.ElapsedMilliseconds);
}
public void OneInsideSFlushDrawWithTwoPair()
{
Stopwatch watch = new Stopwatch();
List <Card> cards = new List <Card>
{
new Card(Rank.Four, Suit.Spades),
new Card(Rank.Four, Suit.Hearts),
new Card(Rank.Five, Suit.Hearts),
new Card(Rank.Six, Suit.Hearts),
new Card(Rank.Eight, Suit.Hearts),
new Card(Rank.Six, Suit.Diamonds),
};
SixCardHand hand = new SixCardHand(cards);
hand.Sort();
watch.Start();
var score = PokerEvaluator.CalculateFlopScore(hand.Cards);
var outs = PokerOutsCalculator.CalculateRiverOuts(hand, score);
watch.Stop();
Assert.AreEqual(1, outs.StraightFlush.Outs);
Assert.Greater(200, watch.ElapsedMilliseconds);
}
public void RemovePair()
{
Stopwatch watch = new Stopwatch();
List <Card> cards = new List <Card>
{
new Card(Rank.Ace, Suit.Hearts),
new Card(Rank.Ace, Suit.Clubs),
new Card(Rank.Six, Suit.Hearts),
new Card(Rank.Seven, Suit.Clubs),
new Card(Rank.Jack, Suit.Hearts),
new Card(Rank.Queen, Suit.Clubs),
};
SixCardHand hand = new SixCardHand(cards);
hand.Sort();
watch.Start();
var newCards = hand.RemovePairs();
watch.Stop();
Assert.AreEqual(5, newCards.Count);
Assert.Greater(10, watch.ElapsedMilliseconds);
Assert.AreEqual(true, newCards[0].Rank == Rank.Six && newCards[1].Rank == Rank.Seven &&
newCards[2].Rank == Rank.Jack && newCards[3].Rank == Rank.Queen &&
newCards[4].Rank == Rank.Ace);
}
public void OneOutsideRFlushWithTwoPair()
{
Stopwatch watch = new Stopwatch();
List <Card> cards = new List <Card>
{
new Card(Rank.Ten, Suit.Hearts),
new Card(Rank.Jack, Suit.Hearts),
new Card(Rank.Queen, Suit.Hearts),
new Card(Rank.King, Suit.Hearts),
new Card(Rank.Jack, Suit.Clubs),
new Card(Rank.Queen, Suit.Diamonds),
};
SixCardHand hand = new SixCardHand(cards);
hand.Sort();
watch.Start();
var score = PokerEvaluator.CalculateFlopScore(hand.Cards);
var outs = PokerOutsCalculator.CalculateRiverOuts(hand, score);
watch.Stop();
Assert.AreEqual(1, outs.RoyalFlush.Outs);
Assert.Greater(250, watch.ElapsedMilliseconds);
}
public static int CalculateRiver(SixCardHand cards)
{
if (cards.HasOutsideStraightDraw())
{
return(6);
}
return(0);
}
public static PokerScoreOuts CalculateRiver(SixCardHand cards)
{
if (cards.HasThreePair())
{
return(PokerHelper.CreateRiverOuts(6));
}
if (cards.HasThreeOfAKind())
{
return(PokerHelper.CreateRiverOuts(9));
}
if (cards.HasTwoPair())
{
return(PokerHelper.CreateRiverOuts(4));
}
return(PokerHelper.CreateRiverOuts(0));
}
public static PokerScoreOuts CalculateRiver(SixCardHand cards)
{
return(cards.HasThreeOfAKind()
? PokerHelper.CreateRiverOuts(1)
: PokerHelper.CreateRiverOuts(0));
}
public static int CalculateRiver(SixCardHand cards)
{
return(0);
}
public static PokerScoreOuts CalculateRiver(SixCardHand cards)
{
return(new PokerScoreOuts {
Outs = 2, Percentage = 4.3, RunnerRunner = false
});
}
public static PokerScoreOuts CalculateRiver(SixCardHand cards)
{
ISet <int> inside = new HashSet <int>(),
outside = new HashSet <int>();
var withoutPair = cards.RemovePairs();
var handList = new List <int> {
cards.Cards[0].ToInt(), cards.Cards[1].ToInt(), cards.Cards[2].ToInt(), cards.Cards[3].ToInt(), cards.Cards[4].ToInt(), cards.Cards[5].ToInt()
};
if (withoutPair.Count <= 3)
{
return(PokerHelper.CreateRiverOuts(0));
}
if (withoutPair.Count == 4)
{
if (withoutPair[3].Rank == Rank.Ace && withoutPair[2].Rank <= Rank.Five)
{
withoutPair = new List <Card> {
withoutPair[3], withoutPair[0], withoutPair[1], withoutPair[2]
}
}
;
outside = PokerHelper.CountOutsideStraightDraws(handList, withoutPair);
if (outside.Count > 0)
{
return(PokerHelper.CreateTurnOuts(outside.Count * 4, false));
}
inside = PokerHelper.CountInsideStraightDraws(handList, withoutPair);
if (inside.Count > 0)
{
return(PokerHelper.CreateTurnOuts(inside.Count * 4, false));
}
return(PokerHelper.CreateRiverOuts(0));
}
if (withoutPair.Count == 5)
{
if (withoutPair[4].Rank == Rank.Ace && withoutPair[2].Rank <= Rank.Five)
{
var comb = new List <Card> {
withoutPair[4], withoutPair[0], withoutPair[1], withoutPair[2]
};
outside.UnionWith(PokerHelper.CountOutsideStraightDraws(handList, comb));
if (outside.Count > 0)
{
return(PokerHelper.CreateTurnOuts(outside.Count * 4, false));
}
inside.UnionWith(PokerHelper.CountInsideStraightDraws(handList, comb));
if (inside.Count > 0)
{
return(PokerHelper.CreateTurnOuts(inside.Count * 4, false));
}
}
foreach (var comb in PokerEnumerator.GetFourCardsFromFive(withoutPair))
{
outside.UnionWith(PokerHelper.CountOutsideStraightDraws(handList, comb));
inside.UnionWith(PokerHelper.CountInsideStraightDraws(handList, comb));
}
outside.UnionWith(inside);
if (outside.Count > 0)
{
return(PokerHelper.CreateRiverOuts(outside.Count * 4));
}
return(PokerHelper.CreateRiverOuts(0));
}
if (withoutPair.Count == 6)
{
if (withoutPair[5].Rank == Rank.Ace && withoutPair[2].Rank <= Rank.Five)
{
var comb = new List <Card> {
withoutPair[5], withoutPair[0], withoutPair[1], withoutPair[2]
};
outside.UnionWith(PokerHelper.CountOutsideStraightDraws(handList, comb));
inside.UnionWith(PokerHelper.CountInsideStraightDraws(handList, comb));
}
foreach (var comb in PokerEnumerator.GetFourCardsFromSix(withoutPair))
{
outside.UnionWith(PokerHelper.CountOutsideStraightDraws(handList, comb));
inside.UnionWith(PokerHelper.CountInsideStraightDraws(handList, comb));
}
outside.UnionWith(inside);
if (outside.Count > 0)
{
return(PokerHelper.CreateRiverOuts(outside.Count * 4));
}
return(PokerHelper.CreateRiverOuts(0));
}
throw new ArgumentException("Without pair count should never be more than six");
}
}
public static PokerScoreOuts CalculateRiver(SixCardHand cards)
{
return(PokerHelper.CreateRiverOuts(18));
}
public static int CalculateRiver(SixCardHand cards)
{
//if there are 4 of the same suit there are 9 more of that suit we can hit
return(cards.CountFlush() == 4 ? 9 : 0);
}
public static PokerOuts CalculateRiverOuts(SixCardHand cards, Pokerscore currentScore)
{
cards.Sort();
PokerOuts.Clear();
switch (currentScore)
{
case Pokerscore.RoyalFlush:
return(PokerOuts);
case Pokerscore.StraightFlush:
PokerOuts.RoyalFlush = RoyalFlushCalculator.CalculateRiver(cards);
return(PokerOuts);
case Pokerscore.FourOfAKind:
PokerOuts.RoyalFlush = RoyalFlushCalculator.CalculateRiver(cards);
PokerOuts.StraightFlush = StraightFlushCalculator.CalculateRiver(cards);
return(PokerOuts);
case Pokerscore.FullHouse:
PokerOuts.RoyalFlush = RoyalFlushCalculator.CalculateRiver(cards);
PokerOuts.StraightFlush = StraightFlushCalculator.CalculateRiver(cards);
PokerOuts.FourOfAKind = FourOfAKindCalculator.RiverOutsDictionary[currentScore]; //done
return(PokerOuts);
case Pokerscore.Flush:
PokerOuts.RoyalFlush = RoyalFlushCalculator.CalculateRiver(cards);
PokerOuts.StraightFlush = StraightFlushCalculator.CalculateRiver(cards);
PokerOuts.FourOfAKind = FourOfAKindCalculator.CalculateRiver(cards);
PokerOuts.FullHouse = FullHouseCalculator.CalculateRiver(cards);
return(PokerOuts);
case Pokerscore.Straight:
PokerOuts.RoyalFlush = RoyalFlushCalculator.CalculateRiver(cards);
PokerOuts.StraightFlush = StraightFlushCalculator.CalculateRiver(cards);
PokerOuts.FourOfAKind = FourOfAKindCalculator.CalculateRiver(cards);
PokerOuts.FullHouse = FullHouseCalculator.CalculateRiver(cards);
PokerOuts.Flush = FlushCalculator.CalculateRiver(cards);//done
return(PokerOuts);
case Pokerscore.ThreeOfAKind:
PokerOuts.RoyalFlush = RoyalFlushCalculator.CalculateRiver(cards);
PokerOuts.StraightFlush = StraightFlushCalculator.CalculateRiver(cards);
PokerOuts.FourOfAKind = FourOfAKindCalculator.RiverOutsDictionary[currentScore]; //done
PokerOuts.FullHouse = FullHouseCalculator.RiverOutsDictionary[currentScore]; //done
PokerOuts.Flush = FlushCalculator.CalculateRiver(cards); //done
PokerOuts.Straight = StraightCalculator.CalculateRiver(cards);
return(PokerOuts);
case Pokerscore.TwoPair:
PokerOuts.RoyalFlush = RoyalFlushCalculator.CalculateRiver(cards);
PokerOuts.StraightFlush = StraightFlushCalculator.CalculateRiver(cards);
PokerOuts.FullHouse = FullHouseCalculator.RiverOutsDictionary[currentScore]; //done
PokerOuts.Flush = FlushCalculator.CalculateRiver(cards); //done
PokerOuts.Straight = StraightCalculator.CalculateRiver(cards);
return(PokerOuts);
case Pokerscore.Pair:
PokerOuts.RoyalFlush = RoyalFlushCalculator.CalculateRiver(cards);
PokerOuts.StraightFlush = StraightFlushCalculator.CalculateRiver(cards);
PokerOuts.Flush = FlushCalculator.CalculateRiver(cards); //done
PokerOuts.ThreeOfAKind = ThreeOfAKindCalculator.CalculateRiver(cards); //done
PokerOuts.Straight = StraightCalculator.CalculateRiver(cards);
PokerOuts.TwoPair = TwoPairCalculator.CalculateRiver(cards); //done
return(PokerOuts);
case Pokerscore.None:
PokerOuts.RoyalFlush = RoyalFlushCalculator.CalculateRiver(cards);
PokerOuts.StraightFlush = StraightFlushCalculator.CalculateRiver(cards);
PokerOuts.Flush = FlushCalculator.CalculateRiver(cards); //done
PokerOuts.Straight = StraightCalculator.CalculateRiver(cards);
PokerOuts.Pair = PairCalculator.CalculateRiver(cards); //done
return(PokerOuts);
default:
return(null);
}
}
public static int CalculateRiver(SixCardHand cards)
{
//Check if there are 3 cards with the same rank, if there are return 1 else return 0
return(0);
}
