Set Validation: The Core Rule Engine for SET: 3D Edition

// Domain layer — zero Unity or Nakama dependencies
public interface ISetValidator
{
    /// <summary>
    /// Checks whether exactly three cards form a valid Set.
    /// Throws ArgumentException if threeCards.Count != 3.
    /// </summary>
    SetResult Validate(IReadOnlyList<Card> threeCards);

    /// <summary>
    /// Returns every valid Set (trio) that exists among the supplied cards.
    /// boardCards may contain 3–21 cards.
    /// </summary>
    IReadOnlyList<Card[]> FindAllSets(IReadOnlyList<Card> boardCards);

    /// <summary>
    /// Returns true as soon as one valid Set is found. Faster than FindAllSets
    /// for the "does any Set exist?" board check.
    /// </summary>
    bool AnySetExists(IReadOnlyList<Card> boardCards);
}

/// <summary>
/// Immutable result of a single Validate() call.
/// </summary>
public readonly struct SetResult
{
    public bool    IsValid       { get; }
    public string? InvalidReason { get; }  // e.g. "Color is mixed" — null when valid

    public SetResult(bool isValid, string? reason)
    {
        IsValid       = isValid;
        InvalidReason = reason;
    }
}

public SetResult Validate(IReadOnlyList<Card> threeCards)
{
    if (threeCards == null || threeCards.Count != 3)
        throw new ArgumentException("Exactly 3 cards are required.", nameof(threeCards));

    var a = threeCards[0].Attributes;
    var b = threeCards[1].Attributes;
    var c = threeCards[2].Attributes;

    if (!IsValidAttribute(a.Number,  b.Number,  c.Number))
        return new SetResult(false, "Number is mixed");
    if (!IsValidAttribute(a.Shape,   b.Shape,   c.Shape))
        return new SetResult(false, "Shape is mixed");
    if (!IsValidAttribute(a.Color,   b.Color,   c.Color))
        return new SetResult(false, "Color is mixed");
    if (!IsValidAttribute(a.Shading, b.Shading, c.Shading))
        return new SetResult(false, "Shading is mixed");

    return new SetResult(true, null);
}

/// <summary>
/// Returns true if x, y, z are all equal OR all different.
/// Mixed (exactly two the same) returns false.
/// </summary>
private static bool IsValidAttribute<T>(T x, T y, T z) where T : Enum
{
    bool allSame = x.Equals(y) && y.Equals(z);
    bool allDiff = !x.Equals(y) && !y.Equals(z) && !x.Equals(z);
    return allSame || allDiff;
}

public IReadOnlyList<Card[]> FindAllSets(IReadOnlyList<Card> boardCards)
{
    if (boardCards == null) throw new ArgumentNullException(nameof(boardCards));

    var results = new List<Card[]>();
    int n = boardCards.Count;

    for (int i = 0; i < n - 2; i++)
    for (int j = i + 1; j < n - 1; j++)
    for (int k = j + 1; k < n;     k++)
    {
        var trio = new[] { boardCards[i], boardCards[j], boardCards[k] };
        if (Validate(trio).IsValid)
            results.Add(trio);
    }

    return results;
}

public bool AnySetExists(IReadOnlyList<Card> boardCards)
{
    if (boardCards == null) throw new ArgumentNullException(nameof(boardCards));

    int n = boardCards.Count;

    for (int i = 0; i < n - 2; i++)
    for (int j = i + 1; j < n - 1; j++)
    for (int k = j + 1; k < n;     k++)
    {
        var trio = new[] { boardCards[i], boardCards[j], boardCards[k] };
        if (Validate(trio).IsValid)
            return true;           // ← short-circuit
    }

    return false;
}