Implement beatmap ruleset selector component (#6393)

Implement beatmap ruleset selector component

Co-authored-by: Dean Herbert <pe@ppy.sh>

osu.Game.Tests/Visual/Online/TestSceneBeatmapRulesetSelector.cs

@@ -0,0 +1,102 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Beatmaps;
+using osu.Game.Overlays.BeatmapSet;
+using osu.Game.Rulesets;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    public class TestSceneBeatmapRulesetSelector : OsuTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(BeatmapRulesetSelector),
+            typeof(BeatmapRulesetTabItem),
+        };
+
+        private readonly TestRulesetSelector selector;
+
+        public TestSceneBeatmapRulesetSelector()
+        {
+            Add(selector = new TestRulesetSelector());
+        }
+
+        [Resolved]
+        private RulesetStore rulesets { get; set; }
+
+        [Test]
+        public void TestMultipleRulesetsBeatmapSet()
+        {
+            var enabledRulesets = rulesets.AvailableRulesets.Skip(1).Take(2);
+
+            AddStep("load multiple rulesets beatmapset", () =>
+            {
+                selector.BeatmapSet = new BeatmapSetInfo
+                {
+                    Beatmaps = enabledRulesets.Select(r => new BeatmapInfo { Ruleset = r }).ToList()
+                };
+            });
+
+            var tabItems = selector.TabContainer.TabItems;
+            AddAssert("other rulesets disabled", () => tabItems.Except(tabItems.Where(t => enabledRulesets.Any(r => r.Equals(t.Value)))).All(t => !t.Enabled.Value));
+            AddAssert("left-most ruleset selected", () => tabItems.First(t => t.Enabled.Value).Active.Value);
+        }
+
+        [Test]
+        public void TestSingleRulesetBeatmapSet()
+        {
+            var enabledRuleset = rulesets.AvailableRulesets.Last();
+
+            AddStep("load single ruleset beatmapset", () =>
+            {
+                selector.BeatmapSet = new BeatmapSetInfo
+                {
+                    Beatmaps = new List<BeatmapInfo>
+                    {
+                        new BeatmapInfo
+                        {
+                            Ruleset = enabledRuleset
+                        }
+                    }
+                };
+            });
+
+            AddAssert("single ruleset selected", () => selector.SelectedTab.Value.Equals(enabledRuleset));
+        }
+
+        [Test]
+        public void TestEmptyBeatmapSet()
+        {
+            AddStep("load empty beatmapset", () => selector.BeatmapSet = new BeatmapSetInfo
+            {
+                Beatmaps = new List<BeatmapInfo>()
+            });
+
+            AddAssert("no ruleset selected", () => selector.SelectedTab == null);
+            AddAssert("all rulesets disabled", () => selector.TabContainer.TabItems.All(t => !t.Enabled.Value));
+        }
+
+        [Test]
+        public void TestNullBeatmapSet()
+        {
+            AddStep("load null beatmapset", () => selector.BeatmapSet = null);
+
+            AddAssert("no ruleset selected", () => selector.SelectedTab == null);
+            AddAssert("all rulesets disabled", () => selector.TabContainer.TabItems.All(t => !t.Enabled.Value));
+        }
+
+        private class TestRulesetSelector : BeatmapRulesetSelector
+        {
+            public new TabItem<RulesetInfo> SelectedTab => base.SelectedTab;
+
+            public new TabFillFlowContainer TabContainer => base.TabContainer;
+        }
+    }
+}

osu.Game/Overlays/BeatmapSet/BeatmapRulesetSelector.cs

@@ -0,0 +1,48 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osuTK;
+using System.Linq;
+
+namespace osu.Game.Overlays.BeatmapSet
+{
+    public class BeatmapRulesetSelector : RulesetSelector
+    {
+        private readonly Bindable<BeatmapSetInfo> beatmapSet = new Bindable<BeatmapSetInfo>();
+
+        public BeatmapSetInfo BeatmapSet
+        {
+            get => beatmapSet.Value;
+            set
+            {
+                // propagate value to tab items first to enable only available rulesets.
+                beatmapSet.Value = value;
+
+                SelectTab(TabContainer.TabItems.FirstOrDefault(t => t.Enabled.Value));
+            }
+        }
+
+        public BeatmapRulesetSelector()
+        {
+            AutoSizeAxes = Axes.Both;
+        }
+
+        protected override TabItem<RulesetInfo> CreateTabItem(RulesetInfo value) => new BeatmapRulesetTabItem(value)
+        {
+            BeatmapSet = { BindTarget = beatmapSet }
+        };
+
+        protected override TabFillFlowContainer CreateTabFlow() => new TabFillFlowContainer
+        {
+            AutoSizeAxes = Axes.Both,
+            Direction = FillDirection.Horizontal,
+            Spacing = new Vector2(10, 0),
+        };
+    }
+}

osu.Game/Overlays/BeatmapSet/BeatmapRulesetTabItem.cs

@@ -0,0 +1,145 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Events;
+using osu.Game.Beatmaps;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets;
+using osuTK;
+using osuTK.Graphics;
+using System.Linq;
+
+namespace osu.Game.Overlays.BeatmapSet
+{
+    public class BeatmapRulesetTabItem : TabItem<RulesetInfo>
+    {
+        private readonly OsuSpriteText name, count;
+        private readonly Box bar;
+
+        public readonly Bindable<BeatmapSetInfo> BeatmapSet = new Bindable<BeatmapSetInfo>();
+
+        public override bool PropagatePositionalInputSubTree => Enabled.Value && !Active.Value && base.PropagatePositionalInputSubTree;
+
+        public BeatmapRulesetTabItem(RulesetInfo value)
+            : base(value)
+        {
+            AutoSizeAxes = Axes.Both;
+
+            FillFlowContainer nameContainer;
+
+            Children = new Drawable[]
+            {
+                nameContainer = new FillFlowContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    AutoSizeAxes = Axes.Both,
+                    Direction = FillDirection.Horizontal,
+                    Margin = new MarginPadding { Bottom = 7.5f },
+                    Spacing = new Vector2(2.5f),
+                    Children = new Drawable[]
+                    {
+                        name = new OsuSpriteText
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Text = value.Name,
+                            Font = OsuFont.Default.With(size: 18),
+                        },
+                        new Container
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            AutoSizeAxes = Axes.Both,
+                            Masking = true,
+                            CornerRadius = 4f,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4.Black.Opacity(0.5f),
+                                },
+                                count = new OsuSpriteText
+                                {
+                                    Alpha = 0,
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    Margin = new MarginPadding { Horizontal = 5f },
+                                    Font = OsuFont.Default.With(weight: FontWeight.SemiBold),
+                                }
+                            }
+                        }
+                    }
+                },
+                bar = new Box
+                {
+                    Anchor = Anchor.BottomCentre,
+                    Origin = Anchor.BottomCentre,
+                    RelativeSizeAxes = Axes.X,
+                },
+                new HoverClickSounds(),
+            };
+
+            BeatmapSet.BindValueChanged(setInfo =>
+            {
+                var beatmapsCount = setInfo.NewValue?.Beatmaps.Count(b => b.Ruleset.Equals(Value)) ?? 0;
+
+                count.Text = beatmapsCount.ToString();
+                count.Alpha = beatmapsCount > 0 ? 1f : 0f;
+
+                Enabled.Value = beatmapsCount > 0;
+            }, true);
+
+            Enabled.BindValueChanged(v => nameContainer.Alpha = v.NewValue ? 1f : 0.5f, true);
+        }
+
+        [Resolved]
+        private OsuColour colour { get; set; }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            count.Colour = colour.Gray9;
+            bar.Colour = colour.Blue;
+
+            updateState();
+        }
+
+        private void updateState()
+        {
+            var isHoveredOrActive = IsHovered || Active.Value;
+
+            bar.ResizeHeightTo(isHoveredOrActive ? 4 : 1, 200, Easing.OutQuint);
+
+            name.Colour = isHoveredOrActive ? colour.GrayE : colour.GrayC;
+            name.Font = name.Font.With(weight: Active.Value ? FontWeight.Bold : FontWeight.Regular);
+        }
+
+        #region Hovering and activation logic
+
+        protected override void OnActivated() => updateState();
+
+        protected override void OnDeactivated() => updateState();
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            updateState();
+            return false;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e) => updateState();
+
+        #endregion
+    }
+}