fix(ScoreFilter): Fix the enumeration comparison logic for ComboFlags and SyncFlags

- Changed `x.ComboFlag >= comboFlag` in ComboScoreFilter to use the `HasFlag` method
- Fixed the counting logic for ComboFlags and SyncFlags in ListService, replacing `>=` comparison with `HasFlag`
- Adjusted the field order of the AchievementInfoRequest message
- Renamed ConstantMap.VersionMap to GenreMap and added the corresponding GenreScoreFilter
- Added FilterScoreProcesser for handling record filtering
- Updated the default icon IDs in DfBestsService and LxnsBestsService
- Added the Flags attribute to the ComboFlags and SyncFlags enumerations and redefined the enumeration values

Author: Yushu2606

src/Prober/Common/ComboFlags.cs

@@ -2,20 +2,25 @@
 
 namespace Limekuma.Prober.Common;
 
+[Flags]
 [JsonConverter(typeof(JsonStringEnumConverter<ComboFlags>))]
 public enum ComboFlags
 {
-    None,
+    [JsonIgnore]
+    None = 0b0000_0000,
+
+    [JsonIgnore]
+    Plus = 0b0000_0001,
 
     [JsonStringEnumMemberName("fc")]
-    FullCombo,
+    FullCombo = 0b0000_0010,
 
     [JsonStringEnumMemberName("fcp")]
-    FullComboPlus,
+    FullComboPlus = FullCombo | Plus,
 
     [JsonStringEnumMemberName("ap")]
-    AllPerfect,
+    AllPerfect = 0b0000_0100,
 
     [JsonStringEnumMemberName("app")]
-    AllPerfectPlus
+    AllPerfectPlus = AllPerfect | Plus
 }

src/Prober/Common/SyncFlags.cs

@@ -2,23 +2,34 @@
 
 namespace Limekuma.Prober.Common;
 
+[Flags]
 [JsonConverter(typeof(JsonStringEnumConverter<SyncFlags>))]
 public enum SyncFlags
 {
-    None,
+    [JsonIgnore]
+    None = 0b0000_0000,
+
+    [JsonStringEnumMemberName("sync")]
+    SyncPlay = 0b0000_0001,
+
+    [JsonIgnore]
+    Full = 0b0000_0010,
 
     [JsonStringEnumMemberName("fs")]
-    FullSync,
+    FullSync = Full | SyncPlay,
+
+    [JsonIgnore]
+    Plus = 0b0000_0100,
 
     [JsonStringEnumMemberName("fsp")]
-    FullSyncPlus,
+    FullSyncPlus = Full | SyncPlay | Plus,
+
+    [JsonIgnore]
+    DX = 0b0000_1000,
 
     [JsonStringEnumMemberName("fsd")]
-    FullSyncDX,
+    FullSyncDX = Full | SyncPlay | DX,
 
     [JsonStringEnumMemberName("fsdp")]
-    FullSyncDXPlus,
-
-    [JsonStringEnumMemberName("sync")]
-    SyncPlay
+    FullSyncDXPlus = Full | SyncPlay | DX | Plus
 }

src/Protos/kumabot.proto

@@ -81,8 +81,8 @@ message ChartInfoRequest {
 
 message AchievementInfoRequest {
   string prober = 1;
-  string difficulty = 2;
-  string songId = 3;
+  string songId = 2;
+  string difficulty = 3;
 }
 
 message ImageResponse {

src/ScoreFilter/ComboScoreFilter.cs

@@ -12,6 +12,6 @@ public Func<CommonRecord, bool> GetFilter(string? condition)
             return _ => true;
         }
 
-        return x => x.ComboFlag >= comboFlag;
+        return x => x.ComboFlag.HasFlag(comboFlag);
     }
 }

src/ScoreFilter/VersionScoreFilter.cs src/ScoreFilter/GenreScoreFilter.cssrc/ScoreFilter/VersionScoreFilter.cs renamed to src/ScoreFilter/GenreScoreFilter.cs

@@ -4,8 +4,8 @@
 
 namespace Limekuma.ScoreFilter;
 
-[ScoreFilterTag("version")]
-public sealed class VersionScoreFilter : IScoreFilter
+[ScoreFilterTag("genre")]
+public sealed class GenreScoreFilter : IScoreFilter
 {
     public Func<CommonRecord, bool> GetFilter(string? condition)
     {
@@ -14,11 +14,11 @@ public Func<CommonRecord, bool> GetFilter(string? condition)
             return _ => true;
         }
 
-        if (!ConstantMap.VersionMap.TryGetValue(condition, out FrozenSet<string>? version))
+        if (!ConstantMap.GenreMap.TryGetValue(condition, out FrozenSet<string>? genre))
         {
             return _ => true;
         }
 
-        return x => version.Contains(x.Chart.Song.Genre);
+        return x => genre.Contains(x.Chart.Song.Genre);
     }
 }

src/ScoreProcesser/FilterScoreProcesser.cs

@@ -0,0 +1,33 @@
+using Limekuma.Prober.Common;
+using Limekuma.Utils;
+using System.Collections.Immutable;
+
+namespace Limekuma.ScoreProcesser;
+
+[ScoreProcesserTag("filter")]
+public sealed class FilterScoreProcesser : IScoreProcesser
+{
+    public (ImmutableArray<CommonRecord>, ImmutableArray<CommonRecord>) Process(IReadOnlyList<CommonRecord> records)
+    {
+        (ImmutableArray<CommonRecord>.Builder Ever, ImmutableArray<CommonRecord>.Builder Current) state = (
+            ImmutableArray.CreateBuilder<CommonRecord>(35), ImmutableArray.CreateBuilder<CommonRecord>(15));
+        (ImmutableArray<CommonRecord>.Builder Ever, ImmutableArray<CommonRecord>.Builder Current) rankedState = records
+            .SortRecordForBests().Aggregate(state, static (acc, record) =>
+            {
+                if (acc.Ever.Count >= 35 && acc.Current.Count >= 15)
+                {
+                    return acc;
+                }
+
+                (record.Chart.Song.InCurrentGenre switch
+                {
+                    true => acc.Current,
+                    false => acc.Ever
+                }).Add(record);
+                return acc;
+            });
+        ImmutableArray<CommonRecord>.Builder ever = rankedState.Ever;
+        ImmutableArray<CommonRecord>.Builder current = rankedState.Current;
+        return (ever.ToImmutable(), current.ToImmutable());
+    }
+}

src/Services/DfBestsService.cs

@@ -90,9 +90,9 @@ public partial class BestsService
             TrophyText = "でらっくま",
             CourseRank = CommonCourseRank.Urakaiden,
             ClassRank = ClassRank.LEGEND,
-            IconId = 1,
-            PlateId = 1,
-            FrameId = 1
+            IconId = 101,
+            PlateId = 55103,
+            FrameId = 109102
         };
 
         await PrepareDataAsync(user, bestEver, bestCurrent);

src/Services/ListService.cs

@@ -79,47 +79,42 @@ private static void AccumulateRecordStats(CommonRecord record, int[] counts)
             counts[6]++;
         }
 
-        if (record.ComboFlag >= ComboFlags.AllPerfectPlus)
+        if (record.ComboFlag.HasFlag(ComboFlags.AllPerfectPlus))
         {
             counts[7]++;
         }
 
-        if (record.ComboFlag >= ComboFlags.AllPerfect)
+        if (record.ComboFlag.HasFlag(ComboFlags.AllPerfect))
         {
             counts[8]++;
         }
 
-        if (record.ComboFlag >= ComboFlags.FullComboPlus)
+        if (record.ComboFlag.HasFlag(ComboFlags.FullComboPlus))
         {
             counts[9]++;
         }
 
-        if (record.ComboFlag >= ComboFlags.FullCombo)
+        if (record.ComboFlag.HasFlag(ComboFlags.FullCombo))
         {
             counts[10]++;
         }
 
-        if (record.SyncFlag is SyncFlags.SyncPlay)
-        {
-            return;
-        }
-
-        if (record.SyncFlag >= SyncFlags.FullSyncDXPlus)
+        if (record.SyncFlag.HasFlag(SyncFlags.FullSyncDXPlus))
         {
             counts[11]++;
         }
 
-        if (record.SyncFlag >= SyncFlags.FullSyncDX)
+        if (record.SyncFlag.HasFlag(SyncFlags.FullSyncDX))
         {
             counts[12]++;
         }
 
-        if (record.SyncFlag >= SyncFlags.FullSyncPlus)
+        if (record.SyncFlag.HasFlag(SyncFlags.FullSyncPlus))
         {
             counts[13]++;
         }
 
-        if (record.SyncFlag >= SyncFlags.FullSync)
+        if (record.SyncFlag.HasFlag(SyncFlags.FullSync))
         {
             counts[14]++;
         }

src/Services/LxnsBestsService.cs

@@ -86,9 +86,9 @@ public partial class BestsService
             TrophyText = "でらっくま",
             CourseRank = CommonCourseRank.Urakaiden,
             ClassRank = ClassRank.LEGEND,
-            IconId = 1,
-            PlateId = 1,
-            FrameId = 1
+            IconId = 101,
+            PlateId = 55103,
+            FrameId = 109102
         };
 
         await PrepareDataAsync(user, bestEver, bestCurrent);

src/Utils/ConstantMap.cs

@@ -24,7 +24,7 @@ private static readonly (float, float, float)[] RatingFactors =
         (101, 0.224f, 15)
     ];
 
-    public static readonly FrozenDictionary<string, FrozenSet<string>> VersionMap =
+    public static readonly FrozenDictionary<string, FrozenSet<string>> GenreMap =
         new Dictionary<string, FrozenSet<string>>
         {
             ["真"] = ["maimai", "maimai PLUS"],