Support request with ruleset name

Author: MingxuanGame

PerformanceServer/BeatmapDifficultyController.cs

@@ -11,12 +11,13 @@
 
 namespace PerformanceServer
 {
-    public class DifficultyRequestBody
+    public class DifficultyRequestBody : INeedsRuleset
     {
         [JsonProperty("beatmap_id")] public int BeatmapId { get; set; }
         [JsonProperty("checksum")] public string? Checksum { get; set; }
         [JsonProperty("mods")] public List<APIMod> Mods { get; set; } = [];
         [JsonProperty("ruleset_id")] public int? RulesetId { get; set; }
+        [JsonProperty("ruleset")] public string? RulesetName { get; set; }
         [JsonProperty("beatmap_file")] public string? BeatmapFile { get; set; }
     }
 
@@ -51,8 +52,7 @@ public async Task<ActionResult<DifficultyAttributes>> CalculateDifficulty([FromB
                 }
             }
 
-            int rulesetId = body.RulesetId ?? workingBeatmap.BeatmapInfo.Ruleset.OnlineID;
-            Ruleset ruleset = Helper.GetRuleset(rulesetId);
+            Ruleset ruleset = Helper.GetRuleset(body, workingBeatmap.BeatmapInfo.Ruleset.OnlineID);
             Mod[] mods = body.Mods.Select(m => m.ToMod(ruleset)).ToArray();
             DifficultyAttributes? difficultyAttributes =
                 ruleset.CreateDifficultyCalculator(workingBeatmap).Calculate(mods);
@@ -61,7 +61,7 @@ public async Task<ActionResult<DifficultyAttributes>> CalculateDifficulty([FromB
                 JsonConvert.DeserializeObject<Dictionary<string, object>>(
                     JsonConvert.SerializeObject(difficultyAttributes));
             if (attr != null)
-                attr["ruleset_id"] = rulesetId;
+                attr["ruleset"] = ruleset.ShortName;
 
             return attr != null ? Ok(attr) : BadRequest("Failed to calculate difficulty.");
         }

PerformanceServer/Helper.cs

@@ -12,27 +12,53 @@ namespace PerformanceServer
 {
     public static class Helper
     {
-        public static Ruleset GetRuleset(int rulesetId)
+        public static Ruleset GetRuleset(INeedsRuleset body, int defaultRulesetId = -1)
         {
-            switch (rulesetId)
+            Ruleset ruleset;
+            if (!string.IsNullOrEmpty(body.RulesetName))
             {
-                default:
-                    throw new ArgumentException("Invalid ruleset ID provided.");
-
-                case 0:
-                    return new OsuRuleset();
+                ruleset = GetRuleset(body.RulesetName);
+            }
+            else if (body.RulesetId != null)
+            {
+                ruleset = GetRuleset(body.RulesetId.Value);
+            }
+            else if (defaultRulesetId >= -1)
+            {
+                ruleset = GetRuleset(defaultRulesetId);
+            }
+            else
+            {
+                throw new ArgumentException("No ruleset provided.");
+            }
 
-                case 1:
-                    return new TaikoRuleset();
+            return ruleset;
+        }
 
-                case 2:
-                    return new CatchRuleset();
+        public static Ruleset GetRuleset(int rulesetId)
+        {
+            return rulesetId switch
+            {
+                0 => GetRuleset("osu"),
+                1 => GetRuleset("taiko"),
+                2 => GetRuleset("fruits"),
+                3 => GetRuleset("mania"),
+                _ => throw new ArgumentException("Invalid ruleset ID provided.")
+            };
+        }
 
-                case 3:
-                    return new ManiaRuleset();
-            }
+        public static Ruleset GetRuleset(string shortName)
+        {
+            return shortName switch
+            {
+                "osu" => new OsuRuleset(),
+                "taiko" => new TaikoRuleset(),
+                "fruits" or "catch" => new CatchRuleset(),
+                "mania" => new ManiaRuleset(),
+                _ => throw new ArgumentException("Invalid ruleset name provided.")
+            };
         }
-        
+
         public static string ComputeMd5(string input)
         {
             byte[] inputBytes = System.Text.Encoding.UTF8.GetBytes(input);

PerformanceServer/INeedsRuleset.cs

@@ -0,0 +1,13 @@
+// Copyright (c) 2025 GooGuTeam
+// Licensed under the MIT Licence. See the LICENCE file in the repository root for full licence text.
+
+using Newtonsoft.Json;
+
+namespace PerformanceServer
+{
+    public interface INeedsRuleset
+    {
+        [JsonProperty("ruleset_id")] int? RulesetId { get; set; }
+        [JsonProperty("ruleset")] string? RulesetName { get; set; }
+    }
+}

PerformanceServer/PerformanceController.cs

@@ -13,14 +13,15 @@
 
 namespace PerformanceServer
 {
-    public class PerformanceRequestBody
+    public class PerformanceRequestBody : INeedsRuleset
     {
         [JsonProperty("beatmap_id")] public int BeatmapId { get; set; }
         [JsonProperty("checksum")] public string? Checksum { get; set; }
         [JsonProperty("mods")] public List<APIMod> Mods { get; set; } = [];
         [JsonProperty("is_legacy")] public bool IsLegacy { get; set; }
         [JsonProperty("accuracy")] public float Accuracy { get; set; }
-        [JsonProperty("ruleset_id")] public int RulesetId { get; set; }
+        [JsonProperty("ruleset_id")] public int? RulesetId { get; set; }
+        [JsonProperty("ruleset")] public string? RulesetName { get; set; }
         [JsonProperty("combo")] public int Combo { get; set; }
         [JsonProperty("statistics")] public Dictionary<HitResult, int> Statistics { get; set; } = new();
         [JsonProperty("beatmap_file")] public string? BeatmapFile { get; set; }
@@ -39,7 +40,16 @@ public class PerformanceController : ControllerBase
         public async Task<ActionResult<PerformanceAttributes>> CalculatePerformance(
             [FromBody] PerformanceRequestBody body)
         {
-            Ruleset ruleset = Helper.GetRuleset(body.RulesetId);
+            Ruleset ruleset;
+            try
+            {
+                ruleset = Helper.GetRuleset(body);
+            }
+            catch (ArgumentException e)
+            {
+                return BadRequest(e.Message);
+            }
+
             List<Mod> mods = body.Mods.Select(m => m.ToMod(ruleset)).ToList();
             if (body.IsLegacy && !mods.Any(m => m is ModClassic))
             {
@@ -51,7 +61,6 @@ public async Task<ActionResult<PerformanceAttributes>> CalculatePerformance(
             ScoreInfo scoreInfo = new()
             {
                 IsLegacyScore = body.IsLegacy,
-                Ruleset = new RulesetInfo { OnlineID = body.RulesetId },
                 BeatmapInfo = new BeatmapInfo { OnlineID = body.BeatmapId },
                 Statistics = body.Statistics,
                 Mods = mods.ToArray(),

README.md

@@ -40,6 +40,7 @@ Request JSON fields:
 - `checksum` (string, optional) MD5 hash used to validate local cached file; if mismatch triggers re-download.
 - `mods` (array, optional) List of osu! API mod objects (typically at least `{ "acronym": "HD" }`). Unsupported or invalid acronyms will be ignored by the underlying conversion if not recognized.
 - `ruleset_id` (int, optional) Override ruleset; if omitted and beatmap file is provided/decoded it falls back to the beatmap's own ruleset.
+- `ruleset_name` (string, optional) Same as above but by name (e.g., `osu`, `taiko`, `fruits`, `mania`). If both ID and name are provided, Name takes precedence.
 - `beatmap_file` (string, optional) Raw `.osu` file content (entire file). If present, `beatmap_id` may still be supplied for caching, but content is authoritative.
 
 Example request using inline file content:
@@ -66,7 +67,8 @@ Request JSON fields:
 - `mods` (array) Same structure as above.
 - `is_legacy` (bool) Whether to treat score as stable scores.
 - `accuracy` (float) Accuracy value (0.0–1.0). Provide either accurate `statistics` or a suitable accuracy.
-- `ruleset_id` (int) Explicit ruleset selection (required here because score construction needs it up-front unless you infer from map; server expects this field).
+- `ruleset_id` (int, optional) Explicit ruleset selection (Either `ruleset_id` or `ruleset_name` must be provided).
+- `ruleset_name` (string, optional) Same as above but by name (e.g., `osu`, `taiko`, `fruits`, `mania`). If both ID and name are provided, Name takes precedence.
 - `combo` (int) Achieved max combo for the score.
 - `statistics` (object) Mapping of hit result enum names to counts. Keys must match `HitResult` enumeration names from osu! (e.g., `great`, `ok`, `meh`, `miss`, `perfect`, `good`, etc. — varies by ruleset). Only relevant ones need to be present.
 
@@ -88,10 +90,9 @@ Minimal example:
 }
 ```
 
-Successful Response: `200 OK` with a JSON `PerformanceAttributes` object with `ruleset_id` including (fields differ by ruleset):
-- `total` (float) Total pp value.
+Successful Response: `200 OK` with a JSON `PerformanceAttributes` object with `ruleset` (name) including (fields differ by ruleset):
+- `pp` (float) Total pp value.
 - Component breakdown fields (aim, speed, flashlight, accuracy, strain, etc.)
-- Embedded `DifficultyAttributes` subset depending on version
 
 Error Cases:
 - `400 Bad Request` – Calculation failed (e.g., malformed beatmap or inconsistent inputs).