Reorganise classes

71_Poker/csharp/Cards/Card.cs

@@ -0,0 +1,11 @@
+namespace Poker.Cards;
+
+internal record struct Card (Rank Rank, Suit Suit)
+{
+    public override string ToString() => $"{Rank} of {Suit}";
+
+    public static bool operator <(Card x, Card y) => x.Rank < y.Rank;
+    public static bool operator >(Card x, Card y) => x.Rank > y.Rank;
+
+    public static int operator -(Card x, Card y) => x.Rank - y.Rank;
+}

71_Poker/csharp/Cards/Deck.cs

@@ -0,0 +1,28 @@
+using static Poker.Cards.Rank;
+
+namespace Poker.Cards;
+
+internal class Deck
+{
+    private readonly Card[] _cards;
+    private int _nextCard;
+
+    public Deck()
+    {
+        _cards = Ranks.SelectMany(r => Enum.GetValues<Suit>().Select(s => new Card(r, s))).ToArray();
+    }
+
+    public void Shuffle(IRandom _random)
+    {
+        for (int i = 0; i < _cards.Length; i++)
+        {
+            var j = _random.Next(_cards.Length);
+            (_cards[i], _cards[j]) = (_cards[j], _cards[i]);
+        }
+        _nextCard = 0;
+    }
+
+    public Card DealCard() => _cards[_nextCard++];
+
+    public Hand DealHand() => new Hand(Enumerable.Range(0, 5).Select(_ => DealCard()));
+}

71_Poker/csharp/Cards/Hand.cs

@@ -0,0 +1,151 @@
+using System.Text;
+
+namespace Poker.Cards;
+
+internal class Hand
+{
+    public static readonly Hand Empty = new Hand();
+
+    private readonly Card[] _cards;
+    private readonly string _name1;
+    private readonly string _name2;
+
+    private Hand()
+    {
+        _cards = Array.Empty<Card>();
+        _name1 = "";
+        _name2 = "";
+        Name = "";
+    }
+
+    public Hand(IEnumerable<Card> cards)
+        : this(cards, isAfterDraw: false)
+    {
+    }
+
+    private Hand(IEnumerable<Card> cards, bool isAfterDraw)
+    {
+        _cards = cards.ToArray();
+        (Rank, _name1, _name2, HighCard, KeepMask) = Analyze();
+        Name = GetHandName();
+
+        IsWeak = Rank < 10
+            || Rank == 10 && isAfterDraw
+            || Rank <= 12 && HighCard.Rank <= 6;
+    }
+
+    public string Name { get; }
+    public int Rank { get; }
+    public Card HighCard { get; }
+    public int KeepMask { get; set; }
+    public bool IsWeak { get; }
+
+    public Hand Replace(int cardNumber, Card newCard)
+    {
+        if (cardNumber < 1 || cardNumber > _cards.Length) { return this; }
+
+        _cards[cardNumber - 1] = newCard;
+        return new Hand(_cards, isAfterDraw: true);
+    }
+
+    private (int, string, string, Card, int) Analyze()
+    {
+        var suitMatchCount = 0;
+        for (var i = 0; i < _cards.Length; i++)
+        {
+            if (i < _cards.Length-1 && _cards[i].Suit == _cards[i+1].Suit)
+            {
+                suitMatchCount++;
+            }
+        }
+        if (suitMatchCount == 4)
+        {
+            return (15, "A Flus", "h in", _cards[0], 0b11111);
+        }
+        var sortedCards = _cards.OrderBy(c => c.Rank).ToArray();
+
+        var handRank = 0;
+        var keepMask = 0;
+        Card highCard = default;
+        var handName1 = "";
+        var handName2 = "";
+        for (var i = 0; i < sortedCards.Length - 1; i++)
+        {
+            if (sortedCards[i].Rank == sortedCards[i+1].Rank)
+            {
+                keepMask |= 0b11 << i;
+                highCard = sortedCards[i];
+                (handRank, handName1, handName2) =
+                    (handRank, i > 0 && sortedCards[i].Rank == sortedCards[i - 1].Rank) switch
+                    {
+                        (<11, _) => (11, "A Pair", " of "),
+                        (11, true) => (13, "Three", " "),
+                        (11, _) => (12, "Two P", "air, "),
+                        (12, _) => (16, "Full H", "ouse, "),
+                        (_, true) => (17, "Four", " "),
+                        _ => (16, "Full H", "ouse, ")
+                    };
+            }
+        }
+        if (keepMask == 0)
+        {
+            if (sortedCards[3] - sortedCards[0] == 3)
+            {
+                keepMask=0b1111;
+                handRank=10;
+            }
+            if (sortedCards[4] - sortedCards[1] == 3)
+            {
+                if (handRank == 10)
+                {
+                    return (14, "Straig", "ht", sortedCards[4], 0b11111);
+                }
+                handRank=10;
+                keepMask=0b11110;
+            }
+        }
+        return handRank < 10
+            ? (9, "Schmal", "tz, ", sortedCards[4], 0b11000)
+            : (handRank, handName1, handName2, highCard, keepMask);
+    }
+
+    private string GetHandName()
+    {
+        var sb = new StringBuilder(_name1).Append(_name2);
+        if (_name1 == "A Flus")
+        {
+            sb.Append(HighCard.Suit).AppendLine();
+        }
+        else
+        {
+            sb.Append(HighCard.Rank)
+                .AppendLine(_name1 == "Schmal" || _name1 == "Straig" ? " High" : "'s");
+        }
+        return sb.ToString();
+    }
+
+    public override string ToString()
+    {
+        var sb = new StringBuilder();
+        for (var i = 0; i < _cards.Length; i++)
+        {
+            var cardDisplay = $" {i+1} --  {_cards[i]}";
+            // Emulates the effect of the BASIC PRINT statement using the ',' to align text to 14-char print zones
+            sb.Append(cardDisplay.PadRight(cardDisplay.Length + 14 - cardDisplay.Length % 14));
+            if (i % 2 == 1)
+            {
+                sb.AppendLine();
+            }
+        }
+        sb.AppendLine();
+        return sb.ToString();
+    }
+
+    public static bool operator >(Hand x, Hand y) =>
+        x.Rank > y.Rank ||
+        x.Rank == y.Rank && x.HighCard > y.HighCard;
+
+    public static bool operator <(Hand x, Hand y) =>
+        x.Rank < y.Rank ||
+        x.Rank == y.Rank && x.HighCard < y.HighCard;
+}

71_Poker/csharp/Cards/Rank.cs

@@ -0,0 +1,50 @@
+namespace Poker.Cards;
+
+internal struct Rank : IComparable<Rank>
+{
+    public static IEnumerable<Rank> Ranks => new[]
+    {
+        Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace
+    };
+
+    public static Rank Two = new(2);
+    public static Rank Three = new(3);
+    public static Rank Four = new(4);
+    public static Rank Five = new(5);
+    public static Rank Six = new(6);
+    public static Rank Seven = new(7);
+    public static Rank Eight = new(8);
+    public static Rank Nine = new(9);
+    public static Rank Ten = new(10);
+    public static Rank Jack = new(11, "Jack");
+    public static Rank Queen = new(12, "Queen");
+    public static Rank King = new(13, "King");
+    public static Rank Ace = new(14, "Ace");
+
+    private readonly int _value;
+    private readonly string _name;
+
+    private Rank(int value, string? name = null)
+    {
+        _value = value;
+        _name = name ?? $" {value} ";
+    }
+
+    public override string ToString() => _name;
+
+    public int CompareTo(Rank other) => this - other;
+
+    public static bool operator <(Rank x, Rank y) => x._value < y._value;
+    public static bool operator >(Rank x, Rank y) => x._value > y._value;
+    public static bool operator ==(Rank x, Rank y) => x._value == y._value;
+    public static bool operator !=(Rank x, Rank y) => x._value != y._value;
+
+    public static int operator -(Rank x, Rank y) => x._value - y._value;
+
+    public static bool operator <=(Rank rank, int value) => rank._value <= value;
+    public static bool operator >=(Rank rank, int value) => rank._value >= value;
+
+    public override bool Equals(object? obj) => obj is Rank other && this == other;
+
+    public override int GetHashCode() => _value.GetHashCode();
+}

71_Poker/csharp/Cards/Suit.cs

@@ -0,0 +1,9 @@
+namespace Poker.Cards;
+
+internal enum Suit
+{
+    Clubs,
+    Diamonds,
+    Hearts,
+    Spades
+}