feat(ScoreFilter): Add extensible score filter system

- Introduce the `IScoreFilter` interface and `ScoreFilterTagAttribute` attribute for defining and tagging filters
- Implement various filters including Level, Rank, DXStar, Combo, Version, Sun, and Lock
- Add the `ScoreFilterHelper` utility class to support dynamic discovery and retrieval of filter instances via tags
- Integrate filters into `LxnsListService` and `DfListService`, replacing the original fixed condition filtering logic
- Add the `ConstantMap` class to centrally manage version mapping and rating constant data
- Adjust Drawer rendering logic to adapt to the new filter data flow

Author: Yushu2606

src/Render/Drawer.cs

@@ -39,21 +39,20 @@ public async Task<Image> DrawBestsAsync(CommonUser user, IReadOnlyList<CommonRec
         return await DrawAsync(scope, xmlPath);
     }
 
-    public async Task<Image> DrawListAsync(CommonUser user, IReadOnlyList<CommonRecord> records, int page, int total,
-        List<int> counts, int startIndex, string condition, string prober, IEnumerable<string> tags) =>
-        await DrawListAsync(user, records, page, total, counts, startIndex, condition, prober, tags, "./Resources/Layouts/list.xml");
+    public async Task<Image> DrawListAsync(CommonUser user, IReadOnlyList<CommonRecord> records, int page,
+        int[] counts, int totalCount, int startIndex, string condition, bool mayMask, string prober, IEnumerable<string> tags) =>
+        await DrawListAsync(user, records, page, counts, totalCount, startIndex, condition, mayMask, prober, tags, "./Resources/Layouts/list.xml");
 
-    public async Task<Image> DrawListAsync(CommonUser user, IReadOnlyList<CommonRecord> records, int page, int total,
-        List<int> counts, int startIndex, string condition, string prober, IEnumerable<string> tags, string xmlPath)
+    public async Task<Image> DrawListAsync(CommonUser user, IReadOnlyList<CommonRecord> records, int page,
+        int[] counts, int totalCount, int startIndex, string condition, bool mayMask, string prober, IEnumerable<string> tags, string xmlPath)
     {
-        int totalCount = counts.Count > 0 ? counts[^1] : 0;
-        bool mayMask = records.Any(r => r.DXScore is 0 && (r.DXStar > 0 || r.Rank > Ranks.A));
+        int totalPages = (int)Math.Ceiling((double)totalCount / 55);
         Dictionary<string, object?> scope = new(StringComparer.OrdinalIgnoreCase)
         {
             ["userInfo"] = user,
             ["pageRecords"] = records,
             ["pageNumber"] = page,
-            ["totalPages"] = total,
+            ["totalPages"] = totalPages,
             ["rankCounts"] = counts[..7],
             ["comboCounts"] = counts[7..^1],
             ["totalCount"] = totalCount,

src/ScoreFilter/ComboScoreFilter.cs

@@ -0,0 +1,19 @@
+using Limekuma.Prober.Common;
+
+namespace Limekuma.ScoreFilter;
+
+[ScoreFilterTag("combo")]
+public sealed class ComboScoreFilter : IScoreFilter
+{
+    public bool MaskMutex => false;
+
+    public Func<CommonRecord, bool> GetFilter(string? condition)
+    {
+        if (!Enum.TryParse(condition, out ComboFlags comboFlag))
+        {
+            return _ => true;
+        }
+
+        return x => x.ComboFlag >= comboFlag;
+    }
+}

src/ScoreFilter/DXStarScoreFilter.cs

@@ -0,0 +1,19 @@
+using Limekuma.Prober.Common;
+
+namespace Limekuma.ScoreFilter;
+
+[ScoreFilterTag("dx_star")]
+public sealed class DXStarScoreFilter : IScoreFilter
+{
+    public bool MaskMutex => false;
+
+    public Func<CommonRecord, bool> GetFilter(string? condition)
+    {
+        if (!int.TryParse(condition, out int dxStar))
+        {
+            return _ => true;
+        }
+
+        return x => x.DXStar >= dxStar;
+    }
+}

src/ScoreFilter/IScoreFilter.cs

@@ -0,0 +1,9 @@
+using Limekuma.Prober.Common;
+
+namespace Limekuma.ScoreFilter;
+
+public interface IScoreFilter
+{
+    Func<CommonRecord, bool> GetFilter(string? condition);
+    bool MaskMutex { get; }
+}

src/ScoreFilter/LevelScoreFilter.cs

@@ -0,0 +1,11 @@
+using Limekuma.Prober.Common;
+
+namespace Limekuma.ScoreFilter;
+
+[ScoreFilterTag("level")]
+public sealed class LevelScoreFilter : IScoreFilter
+{
+    public bool MaskMutex => false;
+
+    public Func<CommonRecord, bool> GetFilter(string? condition) => x => x.Chart.Level == condition;
+}

src/ScoreFilter/LockScoreFilter.cs

@@ -0,0 +1,35 @@
+using Limekuma.Prober.Common;
+using Limekuma.Utils;
+
+namespace Limekuma.ScoreFilter;
+
+[ScoreFilterTag("lock")]
+public sealed class LockScoreFilter : IScoreFilter
+{
+    public bool MaskMutex => true;
+
+    public Func<CommonRecord, bool> GetFilter(string? condition) => x =>
+    {
+        float sumScore = 0;
+        for (int i = 0; i < 5; i++)
+        {
+            (int notes, int weight) = i switch
+            {
+                0 => (x.Chart.Notes.Tap, 1),
+                1 => (x.Chart.Notes.Hold, 2),
+                2 => (x.Chart.Notes.Slide, 3),
+                3 => (x.Chart.Notes.Touch, 1),
+                4 => (x.Chart.Notes.Break, 5),
+                _ => throw new IndexOutOfRangeException()
+            };
+
+            sumScore += notes * weight;
+        }
+
+        sumScore *= 5;
+        float minScore = Math.Min((1 - ((sumScore - 1) / sumScore)) * 100, x.Chart.Notes.Break > 0 ? 1f / x.Chart.Notes.Break / 2 : 101);
+        (float minAcc, _, _) = ConstantMap.RatingMap[x.Rank];
+        float maxAcc = minAcc + minScore;
+        return x.Achievements >= maxAcc && x.Achievements < minAcc;
+    };
+}

src/ScoreFilter/RankScoreFilter.cs

@@ -0,0 +1,19 @@
+using Limekuma.Prober.Common;
+
+namespace Limekuma.ScoreFilter;
+
+[ScoreFilterTag("rank")]
+public sealed class RankScoreFilter : IScoreFilter
+{
+    public bool MaskMutex => false;
+
+    public Func<CommonRecord, bool> GetFilter(string? condition)
+    {
+        if (!Enum.TryParse(condition, out Ranks rank))
+        {
+            return _ => true;
+        }
+
+        return x => x.Rank >= rank;
+    }
+}

src/ScoreFilter/ScoreFilterTagAttribute.cs

@@ -0,0 +1,17 @@
+namespace Limekuma.ScoreFilter;
+
+[AttributeUsage(AttributeTargets.Class, Inherited = false)]
+public sealed class ScoreFilterTagAttribute : Attribute
+{
+    public string Tag { get; }
+
+    public ScoreFilterTagAttribute(string tag)
+    {
+        if (string.IsNullOrWhiteSpace(tag))
+        {
+            throw new ArgumentException("Tag is required.", nameof(tag));
+        }
+
+        Tag = tag;
+    }
+}

src/ScoreFilter/SunScoreFilter.cs

@@ -0,0 +1,35 @@
+using Limekuma.Prober.Common;
+using Limekuma.Utils;
+
+namespace Limekuma.ScoreFilter;
+
+[ScoreFilterTag("sun")]
+public sealed class SunScoreFilter : IScoreFilter
+{
+    public bool MaskMutex => true;
+
+    public Func<CommonRecord, bool> GetFilter(string? condition) => x =>
+    {
+        float sumScore = 0;
+        for (int i = 0; i < 5; i++)
+        {
+            (int notes, int weight) = i switch
+            {
+                0 => (x.Chart.Notes.Tap, 1),
+                1 => (x.Chart.Notes.Hold, 2),
+                2 => (x.Chart.Notes.Slide, 3),
+                3 => (x.Chart.Notes.Touch, 1),
+                4 => (x.Chart.Notes.Break, 5),
+                _ => throw new IndexOutOfRangeException()
+            };
+
+            sumScore += notes * weight;
+        }
+
+        sumScore *= 5;
+        float minScore = Math.Min((1 - ((sumScore - 1) / sumScore)) * 100, x.Chart.Notes.Break > 0 ? 1 / x.Chart.Notes.Break / 2 : 101);
+        (float maxAcc, _, _) = ConstantMap.RatingMap[x.Rank];
+        float minAcc = maxAcc - minScore;
+        return x.Achievements >= minAcc && x.Achievements < maxAcc;
+    };
+}

src/ScoreFilter/VersionScoreFilter.cs

@@ -0,0 +1,26 @@
+using Limekuma.Prober.Common;
+using Limekuma.Utils;
+using System.Collections.Frozen;
+
+namespace Limekuma.ScoreFilter;
+
+[ScoreFilterTag("version")]
+public sealed class VersionScoreFilter : IScoreFilter
+{
+    public bool MaskMutex => false;
+
+    public Func<CommonRecord, bool> GetFilter(string? condition)
+    {
+        if (string.IsNullOrWhiteSpace(condition))
+        {
+            return _ => true;
+        }
+
+        if (!ConstantMap.VersionMap.TryGetValue(condition, out FrozenSet<string>? version))
+        {
+            return _ => true;
+        }
+
+        return x => version.Contains(x.Chart.Song.Genre);
+    }
+}