I found I'm not a huge fan of the video. I don't tend to put a lot of time and effort into each post; it's an opportunity for me to share research and experimentation with the world; as well as give myself a searchable brain. :)
The video took WAY too much time. I figure if I'm going to be trying that again; I'll put it off and it'll have a negative impact to actually getting blogs done.
I'm doing the blogging (for ~year now) for me. I want to be doing it; and I need to be careful to not do things that will interfere with getting it to happen.
I switched to a weekly schedule, I'm not doing videos... It's a work in progress; I like what's happening - but ... No more video's for now.

Which is unfortunate for those interested in my PokerScoreing bit - because this is part two - and not a video. :)

Today I'm implementing the scoring of the different poker hands. With the variant that Suits have weight. Hopefully this doesn't make it more complicated for me. :)

My first test is

[TestMethod]
public void ShouldReturnAceOfSpadesHigherThanOtherNonHand()
{
    //Arrange
    IHand aceOfSpadeHigh = AceOfSpaceHigh;
    IHand aceOfClubHigh = AceOfClubsHigh;
    
    //Act
    bool winning = AceOfSpaceHigh.Beats(AceOfClubsHigh);

    //Assert
    winning.Should().BeTrue();
}

I want to make sure that an Ace of Spades high beats an Ace Of Clubs high.

Which... No. That's not what I want to do. How do I know it's an ace high? That's my first task. Creating the Scoring of A hand.

This leads to a simply check of

[TestMethod]
public void ShouldReturnAceOfSpadesHigh()
{
    //Arrange
    //Act
    IScore score = AceOfSpaceHigh.HandScore();

    //Assert
    score.Should().Be(Score.AceSpadeHigh);
}

I'll do a similar for each of the individual cards.
It's a long list of things; but it's what a score could be. Though... Could a hand every be a TWO high? ... I think the lowest single card high you could have would be a 6. To be lower; you'd have 5 cards; 1-4 +1... what's the remaining one? ... Anything but a 6 would give you a run or two of a kind.

Because it's gonna be kinda boring; I'm gonna add all the Score.{RANK}{SUIT}High statics and then the tests. Lot of duplication and copy and paste; but that's OK for tests. Each test will break for one, and only one, reason.
But I'll only go down to 6 for the 'high' scores.
Except Ace, or 1, is high high. So that makes the lowest single high card a 7.

OK. All the tests inplace to ensure that the high card is returned.
In addition I found that I needed to make sure that each rank was processed so that an Ace of Clubs was scored higher than a Two of Spades.
Tests were put in place for that as well.

At this point I have a giant method;

private IScore ScoreSingleCard()
{
    if (_cards.Contains(Deck.Spades.Ace)) return Score.AceSpadeHigh;
    if (_cards.Contains(Deck.Hearts.Ace)) return Score.AceHeartHigh;
    if (_cards.Contains(Deck.Diamonds.Ace)) return Score.AceDiamondHigh;
    if (_cards.Contains(Deck.Clubs.Ace)) return Score.AceClubHigh;

    if (_cards.Contains(Deck.Spades.King)) return Score.KingSpadeHigh;
    if (_cards.Contains(Deck.Hearts.King)) return Score.KingHeartHigh;
    if (_cards.Contains(Deck.Diamonds.King)) return Score.KingDiamondHigh;
    if (_cards.Contains(Deck.Clubs.King)) return Score.KingClubHigh;

    if (_cards.Contains(Deck.Spades.Queen)) return Score.QueenSpadeHigh;
    if (_cards.Contains(Deck.Hearts.Queen)) return Score.QueenHeartHigh;
    if (_cards.Contains(Deck.Diamonds.Queen)) return Score.QueenDiamondHigh;
    if (_cards.Contains(Deck.Clubs.Queen)) return Score.QueenClubHigh;

    if (_cards.Contains(Deck.Spades.Jack)) return Score.JackSpadeHigh;
    if (_cards.Contains(Deck.Hearts.Jack)) return Score.JackHeartHigh;
    if (_cards.Contains(Deck.Diamonds.Jack)) return Score.JackDiamondHigh;
    if (_cards.Contains(Deck.Clubs.Jack)) return Score.JackClubHigh;

    if (_cards.Contains(Deck.Spades.Ten)) return Score.TenSpadeHigh;
    if (_cards.Contains(Deck.Hearts.Ten)) return Score.TenHeartHigh;
    if (_cards.Contains(Deck.Diamonds.Ten)) return Score.TenDiamondHigh;
    if (_cards.Contains(Deck.Clubs.Ten)) return Score.TenClubHigh;

    if (_cards.Contains(Deck.Spades.Nine)) return Score.NineSpadeHigh;
    if (_cards.Contains(Deck.Hearts.Nine)) return Score.NineHeartHigh;
    if (_cards.Contains(Deck.Diamonds.Nine)) return Score.NineDiamondHigh;
    if (_cards.Contains(Deck.Clubs.Nine)) return Score.NineClubHigh;

    if (_cards.Contains(Deck.Spades.Eight)) return Score.EightSpadeHigh;
    if (_cards.Contains(Deck.Hearts.Eight)) return Score.EightHeartHigh;
    if (_cards.Contains(Deck.Diamonds.Eight)) return Score.EightDiamondHigh;
    if (_cards.Contains(Deck.Clubs.Eight)) return Score.EightClubHigh;

    if (_cards.Contains(Deck.Spades.Seven)) return Score.SevenSpadeHigh;
    if (_cards.Contains(Deck.Hearts.Seven)) return Score.SevenHeartHigh;
    if (_cards.Contains(Deck.Diamonds.Seven)) return Score.SevenDiamondHigh;
    if (_cards.Contains(Deck.Clubs.Seven)) return Score.SevenClubHigh;
    throw new NotImplementedException("Working on it");
}

This will need to be broken down into a chain. I'll stick with a chain as it has temporal coupling. The order matters.
But do I want that right now...

I've been pondering this and a couple other points; and it struck me that I don't need to quite chain this. That's A LOT of almost identical components.

What this can do; is an ordered pair; checking one and then returning the result.

This has created the SingleCardScorer class

public class SingleCardHigh : IScorer
{
    private readonly List<KeyValuePair<ICard, IScore>> _singleCardScores;

    public SingleCardHigh() : this(new List<KeyValuePair<ICard, IScore>>
    {

        new KeyValuePair<ICard, IScore>(Deck.Spades.Ace, Score.AceSpadeHigh),
        new KeyValuePair<ICard, IScore>(Deck.Hearts.Ace, Score.AceHeartHigh),
        new KeyValuePair<ICard, IScore>(Deck.Diamonds.Ace, Score.AceDiamondHigh),
        new KeyValuePair<ICard, IScore>(Deck.Clubs.Ace, Score.AceClubHigh),

        new KeyValuePair<ICard, IScore>(Deck.Spades.King, Score.KingSpadeHigh),
        new KeyValuePair<ICard, IScore>(Deck.Hearts.King, Score.KingHeartHigh),
        new KeyValuePair<ICard, IScore>(Deck.Diamonds.King, Score.KingDiamondHigh),
        new KeyValuePair<ICard, IScore>(Deck.Clubs.King, Score.KingClubHigh),

        new KeyValuePair<ICard, IScore>(Deck.Spades.Queen, Score.QueenSpadeHigh),
        new KeyValuePair<ICard, IScore>(Deck.Hearts.Queen, Score.QueenHeartHigh),
        new KeyValuePair<ICard, IScore>(Deck.Diamonds.Queen, Score.QueenDiamondHigh),
        new KeyValuePair<ICard, IScore>(Deck.Clubs.Queen, Score.QueenClubHigh),

        new KeyValuePair<ICard, IScore>(Deck.Spades.Jack, Score.JackSpadeHigh),
        new KeyValuePair<ICard, IScore>(Deck.Hearts.Jack, Score.JackHeartHigh),
        new KeyValuePair<ICard, IScore>(Deck.Diamonds.Jack, Score.JackDiamondHigh),
        new KeyValuePair<ICard, IScore>(Deck.Clubs.Jack, Score.JackClubHigh),

        new KeyValuePair<ICard, IScore>(Deck.Spades.Ten, Score.TenSpadeHigh),
        new KeyValuePair<ICard, IScore>(Deck.Hearts.Ten, Score.TenHeartHigh),
        new KeyValuePair<ICard, IScore>(Deck.Diamonds.Ten, Score.TenDiamondHigh),
        new KeyValuePair<ICard, IScore>(Deck.Clubs.Ten, Score.TenClubHigh),

        new KeyValuePair<ICard, IScore>(Deck.Spades.Nine, Score.NineSpadeHigh),
        new KeyValuePair<ICard, IScore>(Deck.Hearts.Nine, Score.NineHeartHigh),
        new KeyValuePair<ICard, IScore>(Deck.Diamonds.Nine, Score.NineDiamondHigh),
        new KeyValuePair<ICard, IScore>(Deck.Clubs.Nine, Score.NineClubHigh),

        new KeyValuePair<ICard, IScore>(Deck.Spades.Eight, Score.EightSpadeHigh),
        new KeyValuePair<ICard, IScore>(Deck.Hearts.Eight, Score.EightHeartHigh),
        new KeyValuePair<ICard, IScore>(Deck.Diamonds.Eight, Score.EightDiamondHigh),
        new KeyValuePair<ICard, IScore>(Deck.Clubs.Eight, Score.EightClubHigh),

        new KeyValuePair<ICard, IScore>(Deck.Spades.Seven, Score.SevenSpadeHigh),
        new KeyValuePair<ICard, IScore>(Deck.Hearts.Seven, Score.SevenHeartHigh),
        new KeyValuePair<ICard, IScore>(Deck.Diamonds.Seven, Score.SevenDiamondHigh),
        new KeyValuePair<ICard, IScore>(Deck.Clubs.Seven, Score.SevenClubHigh),
    })
    { }

    public SingleCardHigh(List<KeyValuePair<ICard, IScore>> list) => _singleCardScores = list;

    public IScore HandScore(ICard[] cards)
    {
        foreach (KeyValuePair<ICard, IScore> singleCardScore in _singleCardScores)
        {
            if (cards.Contains(singleCardScore.Key)) return singleCardScore.Value;
        }

        throw new NotImplementedException("Ya broke it");
    }
}

Do I LIKE it... ehh; not as much as I could. I think it should be broken into a chain. But not sure the form yet. I don't think a normal chain. Then I'm passing the internals around. The cards of the hand.
But if I pass the hand down the chain; with a "Do you have X?" method. While I dislike it... I think it's better.

I like what I came out with. It's kinda big and dumb as a chain. Long.
I'm not a huge fan of this long of a chain. It is the correct decision process... just looks wrong.

I've moved onto looking at how I'd find Pairs. I'm not sure I like how I'm identifying the "Score". There's going to be WAY too many objects for each of these.

  • PairTwoSpadeHigh
  • PairTwoHeartHigh
  • PairTwoDiamondHigh

Repeat for every additional rank 13*3 = 39. Plus the 34 for singles.

  • ThreeOfTwoSpadeHigh
  • ThreeOfTwoSpadeDiamond

Repeat for every additional rank 13*2 = 26. This puts up to 99 different score objects. gag It's getting very bloated.

I'm feeling that I should have a score object that takes a Score (Single, Pair, ThreeOf), plus a Card. This would be the "high card".
These two combined would give us the result. It's simpler. Then I just need to ask the Hand for the HighCard; or to build a score object given a score slug.
I like this a lot better.

OK; plan for next time - Nuke everything we did today Code. Then do it better!