Add /available_rulesets route

Author: MingxuanGame

PerformanceServer/AvailableRulesetController.cs

@@ -0,0 +1,32 @@
+// Copyright (c) 2025 GooGuTeam
+// Licensed under the MIT Licence. See the LICENCE file in the repository root for full licence text.
+
+using Microsoft.AspNetCore.Mvc;
+using PerformanceServer.Rulesets;
+
+namespace PerformanceServer
+{
+    [ApiController]
+    [Route("available_rulesets")]
+    public class AvailableRulesetController(IRulesetManager manager) : ControllerBase
+    {
+        [HttpGet]
+        [Produces("application/json")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        public async Task<ActionResult<string[]>> GetAvailableRulesets()
+        {
+            return await Task.FromResult(Ok(new Dictionary<string, string[]>
+            {
+                {
+                    "has_performance_calculator",
+                    manager.GetHasPerformCalculatorRulesets().Select(r => r.ShortName).ToArray()
+                },
+                {
+                    "has_difficulty_calculator",
+                    manager.GetHasDifficultyCalculatorRulesets().Select(r => r.ShortName).ToArray()
+                },
+                { "loaded_rulesets", manager.GetRulesets().Select(r => r.ShortName).ToArray() }
+            }));
+        }
+    }
+}

PerformanceServer/Rulesets/IRulesetManager.cs

@@ -10,5 +10,9 @@ public interface IRulesetManager
         public Ruleset GetRuleset(int rulesetId);
         public Ruleset GetRuleset(string shortName);
         public Ruleset GetRuleset(INeedsRuleset body, int defaultRulesetId = -1);
+
+        public IEnumerable<Ruleset> GetRulesets();
+        public IEnumerable<Ruleset> GetHasPerformCalculatorRulesets();
+        public IEnumerable<Ruleset> GetHasDifficultyCalculatorRulesets();
     }
 }

PerformanceServer/Rulesets/RulesetManager.cs

@@ -3,6 +3,7 @@
 
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Catch;
+using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Taiko;
@@ -18,6 +19,8 @@ public class RulesetManager : IRulesetManager
 
         private readonly Dictionary<string, Ruleset> _rulesets = new();
         private readonly Dictionary<int, Ruleset> _rulesetsById = new();
+        private readonly List<string> _hasPerformanceCalculatorRulesets = new();
+        private readonly List<string> _hasDifficultyCalculatorRulesets = new();
 
         public RulesetManager(ILogger<RulesetManager> logger)
         {
@@ -26,6 +29,22 @@ public RulesetManager(ILogger<RulesetManager> logger)
             LoadFromDisk();
         }
 
+        private static Tuple<bool, bool> GetAttributeTypesForRuleset(Ruleset ruleset)
+        {
+            bool hasPerformanceType = false;
+            bool hasDifficultyType = false;
+
+            foreach (Type type in Assembly.GetAssembly(ruleset.GetType())!.GetTypes())
+            {
+                if (type.IsSubclassOf(typeof(PerformanceCalculator)))
+                    hasPerformanceType = true;
+                else if (type.IsSubclassOf(typeof(DifficultyCalculator)))
+                    hasDifficultyType = true;
+            }
+
+            return Tuple.Create(hasPerformanceType, hasDifficultyType);
+        }
+
         private void AddRuleset(Ruleset ruleset)
         {
             if (!_rulesets.TryAdd(ruleset.ShortName, ruleset))
@@ -34,6 +53,17 @@ private void AddRuleset(Ruleset ruleset)
                 return;
             }
 
+            Tuple<bool, bool> performanceAndDifficultyTypes = GetAttributeTypesForRuleset(ruleset);
+            if (performanceAndDifficultyTypes.Item1)
+            {
+                _hasPerformanceCalculatorRulesets.Add(ruleset.ShortName);
+            }
+
+            if (performanceAndDifficultyTypes.Item2)
+            {
+                _hasDifficultyCalculatorRulesets.Add(ruleset.ShortName);
+            }
+
             if (ruleset is not ILegacyRuleset legacyRuleset)
             {
                 return;
@@ -125,5 +155,20 @@ public Ruleset GetRuleset(INeedsRuleset body, int defaultRulesetId = -1)
 
             return ruleset;
         }
+
+        public IEnumerable<Ruleset> GetRulesets()
+        {
+            return _rulesets.Values;
+        }
+
+        public IEnumerable<Ruleset> GetHasPerformCalculatorRulesets()
+        {
+            return _hasPerformanceCalculatorRulesets.Select(shortName => _rulesets[shortName]);
+        }
+
+        public IEnumerable<Ruleset> GetHasDifficultyCalculatorRulesets()
+        {
+            return _hasDifficultyCalculatorRulesets.Select(shortName => _rulesets[shortName]);
+        }
     }
 }

README.md

@@ -34,7 +34,7 @@ A server for calculating osu! performance points (pp) and star ratings.
 
 - `GET /` returns `{ "status": "ok", "time": "<UTC timestamp>" }` for readiness probes.
 
-### POST /difficulty
+## POST /difficulty
 
 Calculate difficulty attributes for a beatmap (star rating, etc.).
 
@@ -77,7 +77,7 @@ Error Cases:
 - `400 Bad Request` – Internal calculation failed (rare / invalid input).
 - `503 Service Unavailable` – Remote fetch failed (e.g., beatmap not accessible online).
 
-### POST /performance
+## POST /performance
 
 Calculate performance attributes (pp) using both difficulty and supplied score context.
 
@@ -129,6 +129,37 @@ Error Cases:
 - `400 Bad Request` – Calculation failed (e.g., malformed beatmap or inconsistent inputs).
 - `503 Service Unavailable` – Beatmap fetch failed.
 
+## GET /available_rulesets
+
+```bash
+curl -X GET "http://localhost:5225/available_rulesets"
+```
+
+Response: `200 OK` with a JSON object like this:
+
+```json
+{
+  "has_performance_calculator": [
+    "osu",
+    "taiko",
+    "fruits",
+    "mania"
+  ],
+  "has_difficulty_calculator": [
+    "osu",
+    "taiko",
+    "fruits",
+    "mania"
+  ],
+  "loaded_rulesets": [
+    "osu",
+    "taiko",
+    "fruits",
+    "mania"
+  ]
+}
+```
+
 ## Curl Examples
 
 ```bash