allow beatmap conversion from non-std rulesets

Supersedes ppy#23875, fix ppy#9263

Gives the ruleset full control which maps to show both with and without converts enabled - e.g. a competitive/harder version ruleset such as for mania could make mania maps show without enabling converts, as well as control which ones to support only if conversions are enabled in the settings.

There is a CanConvert function in BeatmapConverter which I considered using as well, however it looks like this beatmap converter isn't directly accessible in the carousel and adding it may be quite severe on performance impact. Also consider for example generally mania->taiko converts might be good to have, but a quality control function inside CanConvert could make the conversion fail if it's unplayable, so two different interfaces make more sense in that case.

This way, maps may also show if they fail in conversion, but playing them will show a notification that the maps aren't playable. For the future an async task that just goes through maps to try and see if they are convertible for different modes and caches that might be useful.

I did not change how the default rulesets behave, this is just for custom rulesets to be able to play more maps and start off with a larger pool of maps, which I think is an important part of custom ruleset adoption. I adjusted the scrolling example ruleset (pippidon) to include this as well.

Author: WebFreak001

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Beatmaps/PippidonBeatmapConverter.cs

@@ -28,7 +28,7 @@ public PippidonBeatmapConverter(IBeatmap beatmap, Ruleset ruleset)
             }
         }
 
-        public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition && h is IHasYPosition);
+        public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition || h is IHasYPosition);
 
         protected override IEnumerable<PippidonHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap, CancellationToken cancellationToken)
         {
@@ -43,6 +43,6 @@ protected override IEnumerable<PippidonHitObject> ConvertHitObject(HitObject ori
         private int getLane(HitObject hitObject) => (int)Math.Clamp(
             (getUsablePosition(hitObject) - minPosition) / (maxPosition - minPosition) * PippidonPlayfield.LANE_COUNT, 0, PippidonPlayfield.LANE_COUNT - 1);
 
-        private float getUsablePosition(HitObject h) => (h as IHasYPosition)?.Y ?? ((IHasXPosition)h).X;
+        private float getUsablePosition(HitObject h) => (h as IHasXPosition)?.X ?? ((IHasYPosition)h).Y;
     }
 }

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/Beatmaps/PippidonRulesetConversionSupport.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Filter;
+
+namespace osu.Game.Rulesets.Pippidon.Beatmaps
+{
+    public class PippidonRulesetConversionSupport : IRulesetConvertSupport
+    {
+        public bool CanBePlayed(RulesetInfo ruleset, bool conversionEnabled)
+        {
+            // Always show ctb maps even without converts, since extensive playtesting has shown that the maps match
+            // pippidon very well and we also don't have many maps to start out with yet.
+            // Show std only when converts are enabled
+            return ruleset.ShortName == "pippidon" || ruleset.ShortName == "fruits" ||
+                   (conversionEnabled && ruleset.ShortName == "osu");
+        }
+    }
+}

Templates/Rulesets/ruleset-scrolling-example/osu.Game.Rulesets.Pippidon/PippidonRuleset.cs

@@ -7,6 +7,7 @@
 using osu.Framework.Input.Bindings;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Filter;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Pippidon.Beatmaps;
 using osu.Game.Rulesets.Pippidon.Mods;
@@ -37,6 +38,8 @@ public override IEnumerable<Mod> GetModsFor(ModType type)
             }
         }
 
+        public override IRulesetConvertSupport GetRulesetMapConvertSupport() => new PippidonRulesetConversionSupport();
+
         public override string ShortName => "pippidon";
 
         public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]

osu.Game.Tests/NonVisual/Filtering/FilterMatchingTest.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Bindables;
 using osu.Game.Beatmaps;
@@ -99,6 +100,59 @@ public void TestCriteriaMatchingConvertedBeatmapsForCustomRulesets()
             Assert.IsFalse(carouselItem.Filtered.Value);
         }
 
+        [Test]
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestCriteriaMatchingCustomConvertRules(bool convertsStd)
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                Ruleset = new RulesetInfo { OnlineID = -1, ShortName = "custom" },
+                AllowConvertedBeatmaps = true,
+                RulesetConvertSupport = new CustomConvertSupport(["custom"], convertsStd ? ["osu"] : [])
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.AreEqual(!convertsStd, carouselItem.Filtered.Value);
+        }
+
+        [Test]
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestCriteriaMatchingCustomNativeConvertRules(bool allowConverts)
+        {
+            var exampleBeatmapInfo = getExampleBeatmap();
+            var criteria = new FilterCriteria
+            {
+                Ruleset = new RulesetInfo { OnlineID = -1, ShortName = "custom" },
+                AllowConvertedBeatmaps = allowConverts,
+                RulesetConvertSupport = new CustomConvertSupport(["custom", "osu"], [])
+            };
+            var carouselItem = new CarouselBeatmap(exampleBeatmapInfo);
+            carouselItem.Filter(criteria);
+            Assert.IsFalse(carouselItem.Filtered.Value);
+        }
+
+        private class CustomConvertSupport : IRulesetConvertSupport
+        {
+            private readonly string[] nativeFormats, convertFormats;
+
+            public CustomConvertSupport(string[] nativeFormats, string[] convertFormats)
+            {
+                this.nativeFormats = nativeFormats;
+                this.convertFormats = convertFormats;
+            }
+
+            public bool CanBePlayed(RulesetInfo ruleset, bool conversionEnabled)
+            {
+                if (conversionEnabled && convertFormats.Contains(ruleset.ShortName))
+                    return true;
+
+                return nativeFormats.Contains(ruleset.ShortName);
+            }
+        }
+
         [Test]
         [TestCase(true)]
         [TestCase(false)]

osu.Game/Rulesets/Filter/IRulesetConvertSupport.cs

@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <[email protected]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Screens.Select;
+
+namespace osu.Game.Rulesets.Filter
+{
+    /// <summary>
+    /// Allows for changing which beatmap rulesets are displayed in song select (as implemented in <see cref="FilterCriteria"/>)
+    /// with ruleset-specific criteria.
+    /// </summary>
+    public interface IRulesetConvertSupport
+    {
+        /// <summary>
+        /// Checks whether maps from the supplied <paramref name="ruleset"/> may be played with this ruleset with or
+        /// without beatmap conversion enabled.
+        /// </summary>
+        /// <param name="ruleset">The foreign ruleset to check if it may be played.</param>
+        /// <param name="conversionEnabled">Indicates if the player wants converts or not.</param>
+        /// <returns>
+        /// <c>true</c> if the beatmap can be played and should be shown in the beatmap list,
+        /// <c>false</c> otherwise.
+        /// </returns>
+        bool CanBePlayed(RulesetInfo ruleset, bool conversionEnabled);
+    }
+}

osu.Game/Rulesets/Ruleset.cs

@@ -395,6 +395,13 @@ protected Ruleset()
         /// </summary>
         public virtual IRulesetFilterCriteria? CreateRulesetFilterCriteria() => null;
 
+        /// <summary>
+        /// Creates ruleset-specific conversion support, used in filtering which beatmaps to show based on selected ruleset.
+        /// This interface describes which maps from other rulesets may be used without beatmap conversion enabled and which ones may be used when beatmap conversion is enabled.
+        /// If not set, osu treats this ruleset as the only native format and osu standard as only ruleset that maps can be converted from.
+        /// </summary>
+        public virtual IRulesetConvertSupport? GetRulesetMapConvertSupport() => null;
+
         /// <summary>
         /// Can be overridden to add ruleset-specific sections to the editor beatmap setup screen.
         /// </summary>

osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs

@@ -33,8 +33,9 @@ private bool checkMatch(FilterCriteria criteria)
         {
             bool match =
                 criteria.Ruleset == null ||
-                BeatmapInfo.Ruleset.ShortName == criteria.Ruleset.ShortName ||
-                (BeatmapInfo.Ruleset.OnlineID == 0 && criteria.Ruleset.OnlineID != 0 && criteria.AllowConvertedBeatmaps);
+                (criteria.RulesetConvertSupport?.CanBePlayed(BeatmapInfo.Ruleset, criteria.AllowConvertedBeatmaps) ??
+                      (BeatmapInfo.Ruleset.ShortName == criteria.Ruleset.ShortName ||
+                      (BeatmapInfo.Ruleset.OnlineID == 0 && criteria.Ruleset.OnlineID != 0 && criteria.AllowConvertedBeatmaps)));
 
             if (BeatmapInfo.BeatmapSet?.Equals(criteria.SelectedBeatmapSet) == true)
             {

osu.Game/Screens/Select/FilterControl.cs

@@ -77,7 +77,9 @@ public virtual FilterCriteria CreateCriteria()
             if (!maximumStars.IsDefault)
                 criteria.UserStarDifficulty.Max = maximumStars.Value;
 
-            criteria.RulesetCriteria = ruleset.Value.CreateInstance().CreateRulesetFilterCriteria();
+            var rulesetInstance = ruleset.Value.CreateInstance();
+            criteria.RulesetCriteria = rulesetInstance.CreateRulesetFilterCriteria();
+            criteria.RulesetConvertSupport = rulesetInstance.GetRulesetMapConvertSupport();
 
             FilterQueryParser.ApplyQueries(criteria, query);
             return criteria;

osu.Game/Screens/Select/FilterCriteria.cs

@@ -122,6 +122,12 @@ public string SearchText
 
         public IRulesetFilterCriteria? RulesetCriteria { get; set; }
 
+        /// <summary>
+        /// If set, overrides which maps can be played and should be shown, instead of only showing maps from our own
+        /// ruleset and std with map conversion enabled.
+        /// </summary>
+        public IRulesetConvertSupport? RulesetConvertSupport { get; set; }
+
         public readonly struct OptionalSet<T> : IEquatable<OptionalSet<T>>
             where T : struct, Enum
         {