Poker Game | C# Online Compiler

Poker Game by darth_mallen

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;

namespace Poker
{
    public class Program
    {
        private const int NumberOfPlayers = 4;

        public static void Main()
        {
            var game = new Game(NumberOfPlayers);
            game.SetUp();
            game.Play();

            Console.WriteLine(game.HandDescriptions());
            Console.WriteLine(game.WinnerDescription());
        }
    }

    public class Game
    {
        private Deck Deck { get; set; }
        private List<Player> Players { get; set; }
        private const int NumberOfCardsPerPerson = 5;

        public Game(int numberOfPlayers)
        {
            CreatePlayers(numberOfPlayers);
        }

        public void SetUp()
        {
            Deck = new Deck();
            Deck.Shuffle();
            Deal();
        }

        public void Play()
        {
            Players.ForEach(p => p.HandStrength = PokerService.DetermineHandStrength(p.Hand));
        }

        private void CreatePlayers(int numberOfPlayers)
        {
            Players = new List<Player>();

            for (var i = 1; i <= numberOfPlayers; i++)
            {
                Players.Add(new Player
                {
                    Name = string.Format("Player {0}", i)
                });
            }
        }

        protected void Deal()
        {
            if (NumberOfCardsPerPerson * Players.Count > Deck.CardCount)
            {
                throw new ArgumentException("There are not enough cards in the deck to deal to each player.");
            }

            for (var i = 1; i <= NumberOfCardsPerPerson; i++)
            {
                foreach (var player in Players)
                {
                    player.ReceiveCard(Deck.TakeCard());
                }
            }
        }

        public string HandDescriptions()
        {
            var sb = new StringBuilder();
            foreach (var player in Players)
            {
                sb.Append(player);
            }

            return sb.ToString();
        }

        public string WinnerDescription()
        {
            var winner = Players
                .OrderByDescending(p => p.HandStrength.Strength)
                .First();

            var tiedPlayers = Players.Where(p => p.HandStrength == winner.HandStrength).ToList();

            if (tiedPlayers.Count() > 1)
            {
                var sb = new StringBuilder();
                sb.AppendFormat("There is a {0}-way tie between ", tiedPlayers.Count());
                for (var i = 0; i < tiedPlayers.Count(); i++)
                {
                    sb.Append(i == tiedPlayers.Count - 1 ? " and " : ", ");
                    sb.AppendFormat(tiedPlayers[i].Name);
                }

                return sb.ToString();
            }
            
             
            return string.Format("The winner is: {0} with a {1}", winner.Name, winner.HandStrength.Description);
        }
    }

    public class Deck
    {
        private List<Card> Cards { get; set; }

        public Deck()
        {
            BuildFullDeck();
        }

        public int CardCount {
            get { return Cards.Count; }
        }

        public Card TakeCard()
        {
            if (!Cards.Any())
            {
                throw new NullReferenceException("The deck is out of cards!");
            }

            var card = Cards.First();
            Cards.Remove(card);

            return card;
        }

        public void Shuffle()
        {
            var rnd = new Random();
            for (var i = 0; i < Cards.Count; i++)
            {
                var randomCard = rnd.Next(i, Cards.Count);
                var temp = Cards[i];
                Cards[i] = Cards[randomCard];
                Cards[randomCard] = temp;
            }
        }

        private void BuildFullDeck()
        {
            Cards = new List<Card>();

            foreach (CardSuit suit in Enum.GetValues(typeof(CardSuit)))
            {
                foreach (CardValue value in Enum.GetValues(typeof(CardValue)))
                {
                    Cards.Add(new Card
                    {
                        Value = value,
                        Suit = suit
                    });
                }
            }
        }
    }

    public class Card
    {
        public CardSuit Suit { get; set; }
        public CardValue Value { get; set; }

        public override string ToString()
        {
            return string.Format("[{0}{1}]", Value.Description(), Suit.Description());
        }
    }

    public class Player
    {
        public string Name { get; set; }
        public IList<Card> Hand { get; set; }
        public HandStrength HandStrength { get; set; }

        public void ReceiveCard(Card card)
        {
            if (Hand == null)
            {
                Hand = new List<Card>();
            }
        
            Hand.Add(card);
        }

        public override string ToString()
        {
            var s = new StringBuilder();
            s.AppendLine(Name + ": ");
            s.Append("Cards: ");
            foreach (var card in Hand)
            {
                s.Append(card + " ");
            }
            s.AppendLine("\nResult: " + HandStrength.Description);
            s.AppendLine();

            return s.ToString();
        }
    }

    public class HandStrength
    {
        public string Description { get; set; }
        public float Strength { get; set; }
    }

    public enum CardValue
    {
        [Description("2")]
        Deuce,
        [Description("3")]
        Three,
        [Description("4")]
        Four,
        [Description("5")]
        Five,
        [Description("6")]
        Six,
        [Description("7")]
        Seven,
        [Description("8")]
        Eight,
        [Description("9")]
        Nine,
        [Description("10")]
        Ten,
        [Description("J")]
        Jack,
        [Description("Q")]
        Queen,
        [Description("K")]
        King,
        [Description("A")]
        Ace
    }

    public enum CardSuit
    {
        [Description("♠")]
        Spades,
        [Description("♦")]
        Diamonds,
        [Description("♥")]
        Hearts,
        [Description("♣")]
        Clubs
    }

    public enum HandCategory
    {
        NotSet,
        HighCard,
        Pair,
        TwoPair,
        ThreeOfAKind,
        Straight,
        Flush,
        FullHouse,
        FourOfAKind,
        StraightFlush 
    }

    public static class PokerService
    {
        public static HandStrength DetermineHandStrength(IList<Card> cards)
        {
            var handdstength = new HandStrength();

            var cardValuelist = cards.Select(c => (int)c.Value).ToList();

            // Values for scoring
            // Categories are ordered, a hand with a higher category autoamtically wins
            // If two hands have the same category (ex. both have a pair), the primary, secondary, and terciary additions come into play
            // In the example of a pair, the primary is the value of the pair (ex. pair of 10s is better than a pair of 2s).
            // If two hands have the same category and primary addition (both have a pair of 10s), the secondary and terciary additions come into play.
            // For pairs, the secondary is the first kicker (highest card that's not part of the pair).
            // All cards in the hand can come into play to determine which hand is better. A pair of 2s with a king, queen, jack is better than a pair
            // of 2s with a king, queen, 10 because the jack is a higher value card than the 10.
            // If two hands have the exact same cards, the values will be the same and the players tie.
            var category = HandCategory.NotSet;
            var primaryAddition = 0;
            var secondaryAddition = 0;
            var terciaryAddition = 0;
            var terciary2Addition = 0;
            var terciary3Addition = 0;

            var description = string.Empty;

            var highCard = cardValuelist.Max();
            var isStraight = cardValuelist.Max() - cardValuelist.Min() == 4;
            var isFlush = cards.All(c => c.Suit == cards.First().Suit);

            if (isStraight && isFlush)
            {
                // Straight Flush
                category = HandCategory.StraightFlush;
                primaryAddition = highCard;
                description = ((CardValue)highCard == CardValue.Ace)? "Royal Flush" : "Straight Flush to the " + (CardValue)highCard;
            }
            else if (isFlush)
            {
                // Flush
                category = HandCategory.Flush;
                primaryAddition = highCard;
                description = (CardValue)highCard + " high flush.";
            }
            else if (isStraight)
            {
                // Straight
                category = HandCategory.Straight;
                primaryAddition = highCard;
                description = "Straight to the " + (CardValue)highCard;
            }

            // Pair
            var groups = cardValuelist.GroupBy(x => x).ToList();
            var hasPairing = groups.Any(g => g.Count() > 1);
            if (hasPairing)
            {
                var fourOfAKind = groups.FirstOrDefault(g => g.Count() == 4);
                var threeOfAKind = groups.FirstOrDefault(g => g.Count() == 3);
                var pairs = groups.Where(g => g.Count() == 2).ToList();

                if (fourOfAKind != null)
                {
                    // 4 of a kind
                    category = HandCategory.FourOfAKind;
                    // value of 4 of a kind card
                    primaryAddition = fourOfAKind.Key;
                    // 5th card
                    secondaryAddition = cardValuelist.Where(x => x != fourOfAKind.Key).Max();
                    description = string.Format("Four of a Kind, {0}s", (CardValue)fourOfAKind.Key);
                }
                else if (threeOfAKind != null && pairs.Any())
                {
                    category = HandCategory.FullHouse;
                    // value of trips
                    primaryAddition = threeOfAKind.Key;
                    // value of pair
                    secondaryAddition = pairs.First().Key;
                    description = string.Format("Full House, {0}s over {1}s", (CardValue)threeOfAKind.Key, (CardValue)pairs.First().Key);
                }
                else if (threeOfAKind != null)
                {
                    // Three of a kind
                    category = HandCategory.ThreeOfAKind;
                    // three of a kind card value
                    primaryAddition = threeOfAKind.Key;
                    // high kicker
                    secondaryAddition = cardValuelist.Where(x => x != threeOfAKind.Key).Max();
                    // other kicker
                    terciaryAddition = cardValuelist.Where(x => x != threeOfAKind.Key).Min();
                    description = string.Format("Set of {0}s", (CardValue)threeOfAKind.Key);
                }
                else if (pairs.Count() == 2)
                {
                    // Two Pair
                    category = HandCategory.TwoPair;
                    // high pair
                    primaryAddition = pairs.Select(p => p.Key).Max();
                    // low pair
                    secondaryAddition = pairs.Select(p => p.Key).Min();
                    // 5th card
                    terciaryAddition = groups.First(g => g.Count() == 1).Key;
                    description = string.Format("Two Pair, {0}s over {1}s", (CardValue)primaryAddition, (CardValue)secondaryAddition);
                }
                else if (pairs.Count == 1)
                {
                    // Pair
                    category = HandCategory.Pair;
                    // pair value
                    primaryAddition = pairs.First().Key;
                    var otherCards = groups.Where(g => g.Count() == 1).Select(g => g.Key).OrderBy(x => x).ToList();
                    // high kicker
                    secondaryAddition = otherCards[0];
                    // 2nd kicker
                    terciaryAddition = otherCards[1];
                    // 3rd kicker
                    terciary2Addition = otherCards[2];
                    description = string.Format("Pair of {0}s", (CardValue)primaryAddition);
                }
            }

            if (category == HandCategory.NotSet)
            {
                // High Card
                category = HandCategory.HighCard;
                var orderedCards = cardValuelist.OrderByDescending(x => x).ToList();
                // highest to lowest cards
                primaryAddition = orderedCards[0];
                secondaryAddition = orderedCards[1];
                terciaryAddition = orderedCards[2];
                terciary2Addition = orderedCards[3];
                terciary3Addition = orderedCards[4];
                description = (CardValue)primaryAddition + " High";
            }

            var score = ((int)category * 10000000000) +
                (primaryAddition * 100000000) +
                (secondaryAddition * 1000000) +
                (terciaryAddition * 10000) +
                (terciary2Addition * 100) +
                terciary3Addition;

            handdstength.Description = description;
            handdstength.Strength = score;

            return handdstength;
        }
    }

    public static class EnumExtentions
    {
        /// <summary>
        /// Gets the value of the description attribute of an enum
        /// </summary>
        /// <param name="enumVal"></param>
        /// <returns></returns>
        public static string Description(this Enum enumVal)
        {
            var type = enumVal.GetType();
            var memInfo = type.GetMember(enumVal.ToString());
            var attributes = memInfo[0].GetCustomAttributes(typeof (DescriptionAttribute), false);
            return ((DescriptionAttribute) attributes[0]).Description;
        }
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
​
namespace Poker
{
    public class Program
    {
        private const int NumberOfPlayers = 4;
​
        public static void Main()
        {
            var game = new Game(NumberOfPlayers);
            game.SetUp();
            game.Play();
​
            Console.WriteLine(game.HandDescriptions());
            Console.WriteLine(game.WinnerDescription());
        }
    }
​
    public class Game
    {
        private Deck Deck { get; set; }
        private List<Player> Players { get; set; }
        private const int NumberOfCardsPerPerson = 5;
​
        public Game(int numberOfPlayers)
        {
            CreatePlayers(numberOfPlayers);
        }
​
        public void SetUp()
        {
            Deck = new Deck();
            Deck.Shuffle();
            Deal();
        }
​
        public void Play()
        {
            Players.ForEach(p => p.HandStrength = PokerService.DetermineHandStrength(p.Hand));
        }
​
        private void CreatePlayers(int numberOfPlayers)
        {
            Players = new List<Player>();
​
            for (var i = 1; i <= numberOfPlayers; i++)
            {
                Players.Add(new Player
                {
                    Name = string.Format("Player {0}", i)
                });
            }
        }
​
        protected void Deal()
        {
            if (NumberOfCardsPerPerson * Players.Count > Deck.CardCount)
            {
                throw new ArgumentException("There are not enough cards in the deck to deal to each player.");
            }
​
            for (var i = 1; i <= NumberOfCardsPerPerson; i++)
            {
                foreach (var player in Players)
                {
                    player.ReceiveCard(Deck.TakeCard());
                }
            }
        }
​
        public string HandDescriptions()
        {
            var sb = new StringBuilder();
            foreach (var player in Players)
            {
                sb.Append(player);
            }
​
            return sb.ToString();
        }
​
        public string WinnerDescription()
        {
            var winner = Players
                .OrderByDescending(p => p.HandStrength.Strength)
                .First();
​
            var tiedPlayers = Players.Where(p => p.HandStrength == winner.HandStrength).ToList();
​
            if (tiedPlayers.Count() > 1)
            {
                var sb = new StringBuilder();
                sb.AppendFormat("There is a {0}-way tie between ", tiedPlayers.Count());
                for (var i = 0; i < tiedPlayers.Count(); i++)
                {
                    sb.Append(i == tiedPlayers.Count - 1 ? " and " : ", ");
                    sb.AppendFormat(tiedPlayers[i].Name);
                }
​
                return sb.ToString();
            }
            
             
            return string.Format("The winner is: {0} with a {1}", winner.Name, winner.HandStrength.Description);
        }
    }
​
    public class Deck
    {
        private List<Card> Cards { get; set; }
​
        public Deck()
        {
            BuildFullDeck();
        }
​
        public int CardCount {
            get { return Cards.Count; }
        }
​
        public Card TakeCard()
        {
            if (!Cards.Any())
            {
                throw new NullReferenceException("The deck is out of cards!");
            }
​
            var card = Cards.First();
            Cards.Remove(card);
​
            return card;
        }
​
        public void Shuffle()
        {
            var rnd = new Random();
            for (var i = 0; i < Cards.Count; i++)
            {
                var randomCard = rnd.Next(i, Cards.Count);
                var temp = Cards[i];
                Cards[i] = Cards[randomCard];
                Cards[randomCard] = temp;
            }
        }
​
        private void BuildFullDeck()
        {
            Cards = new List<Card>();
​
            foreach (CardSuit suit in Enum.GetValues(typeof(CardSuit)))
            {
                foreach (CardValue value in Enum.GetValues(typeof(CardValue)))
                {
                    Cards.Add(new Card
                    {
                        Value = value,
                        Suit = suit
                    });
                }
            }
        }
    }
​
    public class Card
    {
        public CardSuit Suit { get; set; }
        public CardValue Value { get; set; }
​
        public override string ToString()
        {
            return string.Format("[{0}{1}]", Value.Description(), Suit.Description());
        }
    }
​
    public class Player
    {
        public string Name { get; set; }
        public IList<Card> Hand { get; set; }
        public HandStrength HandStrength { get; set; }
​
        public void ReceiveCard(Card card)
        {
            if (Hand == null)
            {
                Hand = new List<Card>();
            }
        
            Hand.Add(card);
        }
​
        public override string ToString()
        {
            var s = new StringBuilder();
            s.AppendLine(Name + ": ");
            s.Append("Cards: ");
            foreach (var card in Hand)
            {
                s.Append(card + " ");
            }
            s.AppendLine("\nResult: " + HandStrength.Description);
            s.AppendLine();
​
            return s.ToString();
        }
    }
​
    public class HandStrength
    {
        public string Description { get; set; }
        public float Strength { get; set; }
    }
​
    public enum CardValue
    {
        [Description("2")]
        Deuce,
        [Description("3")]
        Three,
        [Description("4")]
        Four,
        [Description("5")]
        Five,
        [Description("6")]
        Six,
        [Description("7")]
        Seven,
        [Description("8")]
        Eight,
        [Description("9")]
        Nine,
        [Description("10")]
        Ten,
        [Description("J")]
        Jack,
        [Description("Q")]
        Queen,
        [Description("K")]
        King,
        [Description("A")]
        Ace
    }
​
    public enum CardSuit
    {
        [Description("♠")]
        Spades,
        [Description("♦")]
        Diamonds,
        [Description("♥")]
        Hearts,
        [Description("♣")]
        Clubs
    }
​
    public enum HandCategory
    {
        NotSet,
        HighCard,
        Pair,
        TwoPair,
        ThreeOfAKind,
        Straight,
        Flush,
        FullHouse,
        FourOfAKind,
        StraightFlush 
    }
​
    public static class PokerService
    {
        public static HandStrength DetermineHandStrength(IList<Card> cards)
        {
            var handdstength = new HandStrength();
​
            var cardValuelist = cards.Select(c => (int)c.Value).ToList();
​
            // Values for scoring
            // Categories are ordered, a hand with a higher category autoamtically wins
            // If two hands have the same category (ex. both have a pair), the primary, secondary, and terciary additions come into play
            // In the example of a pair, the primary is the value of the pair (ex. pair of 10s is better than a pair of 2s).
            // If two hands have the same category and primary addition (both have a pair of 10s), the secondary and terciary additions come into play.
            // For pairs, the secondary is the first kicker (highest card that's not part of the pair).
            // All cards in the hand can come into play to determine which hand is better. A pair of 2s with a king, queen, jack is better than a pair
            // of 2s with a king, queen, 10 because the jack is a higher value card than the 10.
            // If two hands have the exact same cards, the values will be the same and the players tie.
            var category = HandCategory.NotSet;
            var primaryAddition = 0;
            var secondaryAddition = 0;
            var terciaryAddition = 0;
            var terciary2Addition = 0;
            var terciary3Addition = 0;
​
            var description = string.Empty;
​
            var highCard = cardValuelist.Max();
            var isStraight = cardValuelist.Max() - cardValuelist.Min() == 4;
            var isFlush = cards.All(c => c.Suit == cards.First().Suit);
​
            if (isStraight && isFlush)
            {
                // Straight Flush
                category = HandCategory.StraightFlush;
                primaryAddition = highCard;
                description = ((CardValue)highCard == CardValue.Ace)? "Royal Flush" : "Straight Flush to the " + (CardValue)highCard;
            }
            else if (isFlush)
            {
                // Flush
                category = HandCategory.Flush;
                primaryAddition = highCard;
                description = (CardValue)highCard + " high flush.";
            }
            else if (isStraight)
            {
                // Straight
                category = HandCategory.Straight;
                primaryAddition = highCard;
                description = "Straight to the " + (CardValue)highCard;
            }
​
            // Pair
            var groups = cardValuelist.GroupBy(x => x).ToList();
            var hasPairing = groups.Any(g => g.Count() > 1);
            if (hasPairing)
            {
                var fourOfAKind = groups.FirstOrDefault(g => g.Count() == 4);
                var threeOfAKind = groups.FirstOrDefault(g => g.Count() == 3);
                var pairs = groups.Where(g => g.Count() == 2).ToList();
​
                if (fourOfAKind != null)
                {
                    // 4 of a kind
                    category = HandCategory.FourOfAKind;
                    // value of 4 of a kind card
                    primaryAddition = fourOfAKind.Key;
                    // 5th card
                    secondaryAddition = cardValuelist.Where(x => x != fourOfAKind.Key).Max();
                    description = string.Format("Four of a Kind, {0}s", (CardValue)fourOfAKind.Key);
                }
                else if (threeOfAKind != null && pairs.Any())
                {
                    category = HandCategory.FullHouse;
                    // value of trips
                    primaryAddition = threeOfAKind.Key;
                    // value of pair
                    secondaryAddition = pairs.First().Key;
                    description = string.Format("Full House, {0}s over {1}s", (CardValue)threeOfAKind.Key, (CardValue)pairs.First().Key);
                }
                else if (threeOfAKind != null)
                {
                    // Three of a kind
                    category = HandCategory.ThreeOfAKind;
                    // three of a kind card value
                    primaryAddition = threeOfAKind.Key;
                    // high kicker
                    secondaryAddition = cardValuelist.Where(x => x != threeOfAKind.Key).Max();
                    // other kicker
                    terciaryAddition = cardValuelist.Where(x => x != threeOfAKind.Key).Min();
                    description = string.Format("Set of {0}s", (CardValue)threeOfAKind.Key);
                }
                else if (pairs.Count() == 2)
                {
                    // Two Pair
                    category = HandCategory.TwoPair;
                    // high pair
                    primaryAddition = pairs.Select(p => p.Key).Max();
                    // low pair
                    secondaryAddition = pairs.Select(p => p.Key).Min();
                    // 5th card
                    terciaryAddition = groups.First(g => g.Count() == 1).Key;
                    description = string.Format("Two Pair, {0}s over {1}s", (CardValue)primaryAddition, (CardValue)secondaryAddition);
                }
                else if (pairs.Count == 1)
                {
                    // Pair
                    category = HandCategory.Pair;
                    // pair value
                    primaryAddition = pairs.First().Key;
                    var otherCards = groups.Where(g => g.Count() == 1).Select(g => g.Key).OrderBy(x => x).ToList();
                    // high kicker
                    secondaryAddition = otherCards[0];
                    // 2nd kicker
                    terciaryAddition = otherCards[1];
                    // 3rd kicker
                    terciary2Addition = otherCards[2];
                    description = string.Format("Pair of {0}s", (CardValue)primaryAddition);
                }
            }
​
            if (category == HandCategory.NotSet)
            {
                // High Card
                category = HandCategory.HighCard;
                var orderedCards = cardValuelist.OrderByDescending(x => x).ToList();
                // highest to lowest cards
                primaryAddition = orderedCards[0];
                secondaryAddition = orderedCards[1];
                terciaryAddition = orderedCards[2];
                terciary2Addition = orderedCards[3];
                terciary3Addition = orderedCards[4];
                description = (CardValue)primaryAddition + " High";
            }
​
            var score = ((int)category * 10000000000) +
                (primaryAddition * 100000000) +
                (secondaryAddition * 1000000) +
                (terciaryAddition * 10000) +
                (terciary2Addition * 100) +
                terciary3Addition;
​
            handdstength.Description = description;
            handdstength.Strength = score;
​
            return handdstength;
        }
    }
​
    public static class EnumExtentions
    {
        /// <summary>
        /// Gets the value of the description attribute of an enum
        /// </summary>
        /// <param name="enumVal"></param>
        /// <returns></returns>
        public static string Description(this Enum enumVal)
        {
            var type = enumVal.GetType();
            var memInfo = type.GetMember(enumVal.ToString());
            var attributes = memInfo[0].GetCustomAttributes(typeof (DescriptionAttribute), false);
            return ((DescriptionAttribute) attributes[0]).Description;
        }
    }
}

View IL Code