Merge branch 'master' into taiko-don

osu.Game.Rulesets.Taiko.Tests/DrawableTestHit.cs

@@ -0,0 +1,29 @@
+// 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.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Taiko.Tests
+{
+    internal class DrawableTestHit : DrawableTaikoHitObject
+    {
+        private readonly HitResult type;
+
+        public DrawableTestHit(Hit hit, HitResult type = HitResult.Great)
+            : base(hit)
+        {
+            this.type = type;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Result.Type = type;
+        }
+
+        public override bool OnPressed(TaikoAction action) => false;
+    }
+}

osu.Game.Rulesets.Taiko.Tests/Skinning/TestSceneHitExplosion.cs

@@ -0,0 +1,58 @@
+// 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 System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
+using osu.Game.Rulesets.Taiko.Skinning;
+using osu.Game.Rulesets.Taiko.UI;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Skinning
+{
+    [TestFixture]
+    public class TestSceneHitExplosion : TaikoSkinnableTestScene
+    {
+        public override IReadOnlyList<Type> RequiredTypes => base.RequiredTypes.Concat(new[]
+        {
+            typeof(HitExplosion),
+            typeof(LegacyHitExplosion),
+            typeof(DefaultHitExplosion),
+        }).ToList();
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            AddStep("Great", () => SetContents(() => getContentFor(HitResult.Great)));
+            AddStep("Good", () => SetContents(() => getContentFor(HitResult.Good)));
+            AddStep("Miss", () => SetContents(() => getContentFor(HitResult.Miss)));
+        }
+
+        private Drawable getContentFor(HitResult type)
+        {
+            DrawableTaikoHitObject hit;
+
+            return new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
+                {
+                    hit = createHit(type),
+                    new HitExplosion(hit)
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                }
+            };
+        }
+
+        private DrawableTaikoHitObject createHit(HitResult type) => new DrawableTestHit(new Hit { StartTime = Time.Current }, type);
+    }
+}

osu.Game.Rulesets.Taiko.Tests/TestSceneHits.cs

@@ -149,6 +149,8 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             var h = new DrawableTestHit(hit) { X = RNG.NextSingle(hitResult == HitResult.Good ? -0.1f : -0.05f, hitResult == HitResult.Good ? 0.1f : 0.05f) };
 
+            Add(h);
+
             ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(h, new JudgementResult(new HitObject(), new TaikoJudgement()) { Type = hitResult });
         }
 
@@ -164,6 +166,8 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             var h = new DrawableTestHit(hit) { X = RNG.NextSingle(hitResult == HitResult.Good ? -0.1f : -0.05f, hitResult == HitResult.Good ? 0.1f : 0.05f) };
 
+            Add(h);
+
             ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(h, new JudgementResult(new HitObject(), new TaikoJudgement()) { Type = hitResult });
             ((TaikoPlayfield)drawableRuleset.Playfield).OnNewResult(new TestStrongNestedHit(h), new JudgementResult(new HitObject(), new TaikoStrongJudgement()) { Type = HitResult.Great });
         }
@@ -249,13 +253,5 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
             public override bool OnPressed(TaikoAction action) => false;
         }
-
-        private class DrawableTestHit : DrawableHitObject<TaikoHitObject>
-        {
-            public DrawableTestHit(TaikoHitObject hitObject)
-                : base(hitObject)
-            {
-            }
-        }
     }
 }

osu.Game.Rulesets.Taiko/Skinning/LegacyHitExplosion.cs

@@ -0,0 +1,29 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Containers;
+
+namespace osu.Game.Rulesets.Taiko.Skinning
+{
+    public class LegacyHitExplosion : CompositeDrawable
+    {
+        public LegacyHitExplosion(Drawable sprite)
+        {
+            InternalChild = sprite;
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            AutoSizeAxes = Axes.Both;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            this.FadeIn(120);
+            this.ScaleTo(0.6f).Then().ScaleTo(1, 240, Easing.OutElastic);
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Skinning/TaikoLegacyHitTarget.cs

@@ -31,7 +31,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning
                     {
                         Texture = skin.GetTexture("approachcircle"),
                         Scale = new Vector2(0.73f),
-                        Alpha = 0.7f,
+                        Alpha = 0.47f, // eyeballed to match stable
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
                     },
@@ -39,7 +39,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning
                     {
                         Texture = skin.GetTexture("taikobigcircle"),
                         Scale = new Vector2(0.7f),
-                        Alpha = 0.5f,
+                        Alpha = 0.22f, // eyeballed to match stable
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
                     },

osu.Game.Rulesets.Taiko/Skinning/TaikoLegacySkinTransformer.cs

@@ -1,6 +1,7 @@
 // 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 System;
 using System.Collections.Generic;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
@@ -83,15 +84,41 @@ namespace osu.Game.Rulesets.Taiko.Skinning
 
                     return null;
 
+                case TaikoSkinComponents.TaikoExplosionGood:
+                case TaikoSkinComponents.TaikoExplosionGreat:
+                case TaikoSkinComponents.TaikoExplosionMiss:
+
+                    var sprite = this.GetAnimation(getHitName(taikoComponent.Component), true, false);
+                    if (sprite != null)
+                        return new LegacyHitExplosion(sprite);
+
+                    return null;
+
                 case TaikoSkinComponents.TaikoDon:
                     if (GetTexture("pippidonclear0") != null)
                         return new DrawableTaikoMascot();
 
                     return null;
-
-                default:
-                    return source.GetDrawableComponent(component);
             }
+
+            return source.GetDrawableComponent(component);
+        }
+
+        private string getHitName(TaikoSkinComponents component)
+        {
+            switch (component)
+            {
+                case TaikoSkinComponents.TaikoExplosionMiss:
+                    return "taiko-hit0";
+
+                case TaikoSkinComponents.TaikoExplosionGood:
+                    return "taiko-hit100";
+
+                case TaikoSkinComponents.TaikoExplosionGreat:
+                    return "taiko-hit300";
+            }
+
+            throw new ArgumentOutOfRangeException(nameof(component), "Invalid result type");
         }
 
         public Texture GetTexture(string componentName) => source.GetTexture(componentName);

osu.Game.Rulesets.Taiko/TaikoSkinComponents.cs

@@ -15,6 +15,9 @@ namespace osu.Game.Rulesets.Taiko
         PlayfieldBackgroundLeft,
         PlayfieldBackgroundRight,
         BarLine,
-        TaikoDon
+        TaikoExplosionMiss,
+        TaikoExplosionGood,
+        TaikoExplosionGreat,
+        TaikoDon,
     }
 }

osu.Game.Rulesets.Taiko/UI/DefaultHitExplosion.cs

@@ -0,0 +1,54 @@
+// 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.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Objects;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Taiko.UI
+{
+    internal class DefaultHitExplosion : CircularContainer
+    {
+        [Resolved]
+        private DrawableHitObject judgedObject { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            BorderColour = Color4.White;
+            BorderThickness = 1;
+
+            Alpha = 0.15f;
+            Masking = true;
+
+            if (judgedObject.Result.Type == HitResult.Miss)
+                return;
+
+            bool isRim = (judgedObject.HitObject as Hit)?.Type == HitType.Rim;
+
+            InternalChildren = new[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = isRim ? colours.BlueDarker : colours.PinkDarker,
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            this.ScaleTo(3f, 1000, Easing.OutQuint);
+        }
+    }
+}

osu.Game.Rulesets.Taiko/UI/HitExplosion.cs

@@ -1,15 +1,15 @@
 // 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 System;
 using osuTK;
-using osuTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
@@ -20,15 +20,12 @@ namespace osu.Game.Rulesets.Taiko.UI
     {
         public override bool RemoveWhenNotAlive => true;
 
+        [Cached(typeof(DrawableHitObject))]
         public readonly DrawableHitObject JudgedObject;
-        private readonly HitType type;
 
-        private readonly Box innerFill;
+        public HitExplosion(DrawableHitObject judgedObject)
-
-        public HitExplosion(DrawableHitObject judgedObject, HitType type)
         {
             JudgedObject = judgedObject;
-            this.type = type;
 
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
@@ -37,35 +34,36 @@ namespace osu.Game.Rulesets.Taiko.UI
             Size = new Vector2(TaikoHitObject.DEFAULT_SIZE);
 
             RelativePositionAxes = Axes.Both;
-
-            BorderColour = Color4.White;
-            BorderThickness = 1;
-
-            Alpha = 0.15f;
-            Masking = true;
-
-            Children = new[]
-            {
-                innerFill = new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                }
-            };
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private void load()
         {
-            innerFill.Colour = type == HitType.Rim ? colours.BlueDarker : colours.PinkDarker;
+            Child = new SkinnableDrawable(new TaikoSkinComponent(getComponentName(JudgedObject.Result?.Type ?? HitResult.Great)), _ => new DefaultHitExplosion());
+        }
+
+        private TaikoSkinComponents getComponentName(HitResult resultType)
+        {
+            switch (resultType)
+            {
+                case HitResult.Miss:
+                    return TaikoSkinComponents.TaikoExplosionMiss;
+
+                case HitResult.Good:
+                    return TaikoSkinComponents.TaikoExplosionGood;
+
+                case HitResult.Great:
+                    return TaikoSkinComponents.TaikoExplosionGreat;
+            }
+
+            throw new ArgumentOutOfRangeException(nameof(resultType), "Invalid result type");
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            this.ScaleTo(3f, 1000, Easing.OutQuint);
             this.FadeOut(500);
-
             Expire(true);
         }
 

osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs

@@ -194,7 +194,6 @@ namespace osu.Game.Rulesets.Taiko.UI
                     var drawableTick = (DrawableDrumRollTick)judgedObject;
 
                     addDrumRollHit(drawableTick);
-                    addExplosion(drawableTick, drawableTick.JudgementType);
                     break;
 
                 default:
@@ -209,7 +208,9 @@ namespace osu.Game.Rulesets.Taiko.UI
                     if (!result.IsHit)
                         break;
 
-                    addExplosion(judgedObject, (judgedObject.HitObject as Hit)?.Type ?? HitType.Centre);
+                    var type = (judgedObject.HitObject as Hit)?.Type ?? HitType.Centre;
+
+                    addExplosion(judgedObject, type);
                     break;
             }
 
@@ -229,7 +230,7 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         private void addExplosion(DrawableHitObject drawableObject, HitType type)
         {
-            hitExplosionContainer.Add(new HitExplosion(drawableObject, type));
+            hitExplosionContainer.Add(new HitExplosion(drawableObject));
             if (drawableObject.HitObject.Kiai)
                 kiaiExplosionContainer.Add(new KiaiHitExplosion(drawableObject, type));
         }

osu.Game.Tests/Visual/UserInterface/TestSceneModSelectOverlay.cs

@@ -14,8 +14,6 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Mods;
 using osu.Game.Overlays.Mods.Sections;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Mania;
-using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
@@ -117,8 +115,6 @@ namespace osu.Game.Tests.Visual.UserInterface
         public void TestManiaMods()
         {
             changeRuleset(3);
-
-            testRankedText(new ManiaRuleset().GetModsFor(ModType.Conversion).First(m => m is ManiaModRandom));
         }
 
         [Test]
@@ -217,15 +213,6 @@ namespace osu.Game.Tests.Visual.UserInterface
             checkLabelColor(() => Color4.White);
         }
 
-        private void testRankedText(Mod mod)
-        {
-            AddUntilStep("check for ranked", () => modSelect.UnrankedLabel.Alpha == 0);
-            selectNext(mod);
-            AddUntilStep("check for unranked", () => modSelect.UnrankedLabel.Alpha != 0);
-            selectPrevious(mod);
-            AddUntilStep("check for ranked", () => modSelect.UnrankedLabel.Alpha == 0);
-        }
-
         private void selectNext(Mod mod) => AddStep($"left click {mod.Name}", () => modSelect.GetModButton(mod)?.SelectNext(1));
 
         private void selectPrevious(Mod mod) => AddStep($"right click {mod.Name}", () => modSelect.GetModButton(mod)?.SelectNext(-1));
@@ -272,7 +259,6 @@ namespace osu.Game.Tests.Visual.UserInterface
             }
 
             public new OsuSpriteText MultiplierLabel => base.MultiplierLabel;
-            public new OsuSpriteText UnrankedLabel => base.UnrankedLabel;
             public new TriangleButton DeselectAllButton => base.DeselectAllButton;
 
             public new Color4 LowMultiplierColour => base.LowMultiplierColour;

osu.Game.Tests/Visual/UserInterface/TestSceneNowPlayingOverlay.cs

@@ -1,12 +1,15 @@
 // 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 System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
 using osu.Framework.Graphics;
-using osu.Framework.Utils;
+using osu.Framework.Platform;
 using osu.Game.Beatmaps;
 using osu.Game.Overlays;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Osu;
 
 namespace osu.Game.Tests.Visual.UserInterface
@@ -21,9 +24,14 @@ namespace osu.Game.Tests.Visual.UserInterface
 
         private NowPlayingOverlay nowPlayingOverlay;
 
+        private RulesetStore rulesets;
+
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(AudioManager audio, GameHost host)
         {
+            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
+
             Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
 
             nowPlayingOverlay = new NowPlayingOverlay
@@ -44,21 +52,43 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddStep(@"hide", () => nowPlayingOverlay.Hide());
         }
 
+        private BeatmapManager manager { get; set; }
+
+        private int importId;
+
         [Test]
         public void TestPrevTrackBehavior()
         {
-            AddStep(@"Play track", () =>
+            // ensure we have at least two beatmaps available.
+            AddRepeatStep("import beatmap", () => manager.Import(new BeatmapSetInfo
             {
-                musicController.NextTrack();
+                Beatmaps = new List<BeatmapInfo>
-                currentBeatmap = Beatmap.Value;
+                {
-            });
+                    new BeatmapInfo
+                    {
+                        BaseDifficulty = new BeatmapDifficulty(),
+                    }
+                },
+                Metadata = new BeatmapMetadata
+                {
+                    Artist = $"a test map {importId++}",
+                    Title = "title",
+                }
+            }).Wait(), 5);
+
+            AddStep(@"Next track", () => musicController.NextTrack());
+            AddStep("Store track", () => currentBeatmap = Beatmap.Value);
 
             AddStep(@"Seek track to 6 second", () => musicController.SeekTo(6000));
             AddUntilStep(@"Wait for current time to update", () => currentBeatmap.Track.CurrentTime > 5000);
-            AddAssert(@"Check action is restart track", () => musicController.PreviousTrack() == PreviousTrackResult.Restart);
+
-            AddUntilStep("Wait for current time to update", () => Precision.AlmostEquals(currentBeatmap.Track.CurrentTime, 0));
+            AddStep(@"Set previous", () => musicController.PreviousTrack());
-            AddAssert(@"Check track didn't change", () => currentBeatmap == Beatmap.Value);
+
-            AddAssert(@"Check action is not restart", () => musicController.PreviousTrack() != PreviousTrackResult.Restart);
+            AddAssert(@"Check beatmap didn't change", () => currentBeatmap == Beatmap.Value);
+            AddUntilStep("Wait for current time to update", () => currentBeatmap.Track.CurrentTime < 5000);
+
+            AddStep(@"Set previous", () => musicController.PreviousTrack());
+            AddAssert(@"Check beatmap did change", () => currentBeatmap != Beatmap.Value);
         }
     }
 }

osu.Game/Beatmaps/BeatmapManager.cs

@@ -246,6 +246,12 @@ namespace osu.Game.Beatmaps
             if (beatmapInfo?.BeatmapSet == null || beatmapInfo == DefaultBeatmap?.BeatmapInfo)
                 return DefaultBeatmap;
 
+            if (beatmapInfo.BeatmapSet.Files == null)
+            {
+                var info = beatmapInfo;
+                beatmapInfo = QueryBeatmap(b => b.ID == info.ID);
+            }
+
             lock (workingCache)
             {
                 var working = workingCache.FirstOrDefault(w => w.BeatmapInfo?.ID == beatmapInfo.ID);
@@ -287,13 +293,34 @@ namespace osu.Game.Beatmaps
         /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s.
         /// </summary>
         /// <returns>A list of available <see cref="BeatmapSetInfo"/>.</returns>
-        public List<BeatmapSetInfo> GetAllUsableBeatmapSets() => GetAllUsableBeatmapSetsEnumerable().ToList();
+        public List<BeatmapSetInfo> GetAllUsableBeatmapSets(IncludedDetails includes = IncludedDetails.All) => GetAllUsableBeatmapSetsEnumerable(includes).ToList();
 
         /// <summary>
-        /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s.
+        /// Returns a list of all usable <see cref="BeatmapSetInfo"/>s. Note that files are not populated.
         /// </summary>
+        /// <param name="includes">The level of detail to include in the returned objects.</param>
         /// <returns>A list of available <see cref="BeatmapSetInfo"/>.</returns>
-        public IQueryable<BeatmapSetInfo> GetAllUsableBeatmapSetsEnumerable() => beatmaps.ConsumableItems.Where(s => !s.DeletePending && !s.Protected);
+        public IQueryable<BeatmapSetInfo> GetAllUsableBeatmapSetsEnumerable(IncludedDetails includes)
+        {
+            IQueryable<BeatmapSetInfo> queryable;
+
+            switch (includes)
+            {
+                case IncludedDetails.Minimal:
+                    queryable = beatmaps.BeatmapSetsOverview;
+                    break;
+
+                case IncludedDetails.AllButFiles:
+                    queryable = beatmaps.BeatmapSetsWithoutFiles;
+                    break;
+
+                default:
+                    queryable = beatmaps.ConsumableItems;
+                    break;
+            }
+
+            return queryable.Where(s => !s.DeletePending && !s.Protected);
+        }
 
         /// <summary>
         /// Perform a lookup query on available <see cref="BeatmapSetInfo"/>s.
@@ -482,4 +509,25 @@ namespace osu.Game.Beatmaps
             }
         }
     }
+
+    /// <summary>
+    /// The level of detail to include in database results.
+    /// </summary>
+    public enum IncludedDetails
+    {
+        /// <summary>
+        /// Only include beatmap difficulties and set level metadata.
+        /// </summary>
+        Minimal,
+
+        /// <summary>
+        /// Include all difficulties, rulesets, difficulty metadata but no files.
+        /// </summary>
+        AllButFiles,
+
+        /// <summary>
+        /// Include everything.
+        /// </summary>
+        All
+    }
 }

osu.Game/Beatmaps/BeatmapStore.cs

@@ -87,6 +87,18 @@ namespace osu.Game.Beatmaps
             base.Purge(items, context);
         }
 
+        public IQueryable<BeatmapSetInfo> BeatmapSetsOverview => ContextFactory.Get().BeatmapSetInfo
+                                                                               .Include(s => s.Metadata)
+                                                                               .Include(s => s.Beatmaps)
+                                                                               .AsNoTracking();
+
+        public IQueryable<BeatmapSetInfo> BeatmapSetsWithoutFiles => ContextFactory.Get().BeatmapSetInfo
+                                                                                   .Include(s => s.Metadata)
+                                                                                   .Include(s => s.Beatmaps).ThenInclude(s => s.Ruleset)
+                                                                                   .Include(s => s.Beatmaps).ThenInclude(b => b.BaseDifficulty)
+                                                                                   .Include(s => s.Beatmaps).ThenInclude(b => b.Metadata)
+                                                                                   .AsNoTracking();
+
         public IQueryable<BeatmapInfo> Beatmaps =>
             ContextFactory.Get().BeatmapInfo
                           .Include(b => b.BeatmapSet).ThenInclude(s => s.Metadata)

osu.Game/Overlays/Mods/ModSelectOverlay.cs

@@ -37,7 +37,6 @@ namespace osu.Game.Overlays.Mods
         protected readonly TriangleButton CloseButton;
 
         protected readonly OsuSpriteText MultiplierLabel;
-        protected readonly OsuSpriteText UnrankedLabel;
 
         protected override bool BlockNonPositionalInput => false;
 
@@ -57,6 +56,8 @@ namespace osu.Game.Overlays.Mods
         protected Color4 HighMultiplierColour;
 
         private const float content_width = 0.8f;
+        private const float footer_button_spacing = 20;
+
         private readonly FillFlowContainer footerContainer;
 
         private SampleChannel sampleOn, sampleOff;
@@ -103,7 +104,7 @@ namespace osu.Game.Overlays.Mods
                     {
                         new Dimension(GridSizeMode.Absolute, 90),
                         new Dimension(GridSizeMode.Distributed),
-                        new Dimension(GridSizeMode.Absolute, 70),
+                        new Dimension(GridSizeMode.AutoSize),
                     },
                     Content = new[]
                     {
@@ -197,7 +198,8 @@ namespace osu.Game.Overlays.Mods
                             // Footer
                             new Container
                             {
-                                RelativeSizeAxes = Axes.Both,
+                                RelativeSizeAxes = Axes.X,
+                                AutoSizeAxes = Axes.Y,
                                 Origin = Anchor.TopCentre,
                                 Anchor = Anchor.TopCentre,
                                 Children = new Drawable[]
@@ -215,7 +217,9 @@ namespace osu.Game.Overlays.Mods
                                         AutoSizeAxes = Axes.Y,
                                         RelativeSizeAxes = Axes.X,
                                         Width = content_width,
-                                        Direction = FillDirection.Horizontal,
+                                        Spacing = new Vector2(footer_button_spacing, footer_button_spacing / 2),
+                                        LayoutDuration = 100,
+                                        LayoutEasing = Easing.OutQuint,
                                         Padding = new MarginPadding
                                         {
                                             Vertical = 15,
@@ -228,10 +232,8 @@ namespace osu.Game.Overlays.Mods
                                                 Width = 180,
                                                 Text = "Deselect All",
                                                 Action = DeselectAll,
-                                                Margin = new MarginPadding
+                                                Origin = Anchor.CentreLeft,
-                                                {
+                                                Anchor = Anchor.CentreLeft,
-                                                    Right = 20
-                                                }
                                             },
                                             CustomiseButton = new TriangleButton
                                             {
@@ -239,49 +241,41 @@ namespace osu.Game.Overlays.Mods
                                                 Text = "Customisation",
                                                 Action = () => ModSettingsContainer.Alpha = ModSettingsContainer.Alpha == 1 ? 0 : 1,
                                                 Enabled = { Value = false },
-                                                Margin = new MarginPadding
+                                                Origin = Anchor.CentreLeft,
-                                                {
+                                                Anchor = Anchor.CentreLeft,
-                                                    Right = 20
-                                                }
                                             },
                                             CloseButton = new TriangleButton
                                             {
                                                 Width = 180,
                                                 Text = "Close",
                                                 Action = Hide,
-                                                Margin = new MarginPadding
+                                                Origin = Anchor.CentreLeft,
-                                                {
+                                                Anchor = Anchor.CentreLeft,
-                                                    Right = 20
-                                                }
                                             },
-                                            new OsuSpriteText
+                                            new FillFlowContainer
                                             {
-                                                Text = @"Score Multiplier:",
+                                                AutoSizeAxes = Axes.Both,
-                                                Font = OsuFont.GetFont(size: 30),
+                                                Spacing = new Vector2(footer_button_spacing / 2, 0),
-                                                Margin = new MarginPadding
+                                                Origin = Anchor.CentreLeft,
+                                                Anchor = Anchor.CentreLeft,
+                                                Children = new Drawable[]
                                                 {
-                                                    Top = 5,
+                                                    new OsuSpriteText
-                                                    Right = 10
+                                                    {
-                                                }
+                                                        Text = @"Score Multiplier:",
+                                                        Font = OsuFont.GetFont(size: 30),
+                                                        Origin = Anchor.CentreLeft,
+                                                        Anchor = Anchor.CentreLeft,
+                                                    },
+                                                    MultiplierLabel = new OsuSpriteText
+                                                    {
+                                                        Font = OsuFont.GetFont(size: 30, weight: FontWeight.Bold),
+                                                        Origin = Anchor.CentreLeft,
+                                                        Anchor = Anchor.CentreLeft,
+                                                        Width = 70, // make width fixed so reflow doesn't occur when multiplier number changes.
+                                                    },
+                                                },
                                             },
-                                            MultiplierLabel = new OsuSpriteText
-                                            {
-                                                Font = OsuFont.GetFont(size: 30, weight: FontWeight.Bold),
-                                                Margin = new MarginPadding
-                                                {
-                                                    Top = 5
-                                                }
-                                            },
-                                            UnrankedLabel = new OsuSpriteText
-                                            {
-                                                Text = @"(Unranked)",
-                                                Font = OsuFont.GetFont(size: 30, weight: FontWeight.Bold),
-                                                Margin = new MarginPadding
-                                                {
-                                                    Top = 5,
-                                                    Left = 10
-                                                }
-                                            }
                                         }
                                     }
                                 },
@@ -327,7 +321,6 @@ namespace osu.Game.Overlays.Mods
         {
             LowMultiplierColour = colours.Red;
             HighMultiplierColour = colours.Green;
-            UnrankedLabel.Colour = colours.Blue;
 
             availableMods = osu.AvailableMods.GetBoundCopy();
 
@@ -431,12 +424,10 @@ namespace osu.Game.Overlays.Mods
         private void updateMods()
         {
             var multiplier = 1.0;
-            var ranked = true;
 
             foreach (var mod in SelectedMods.Value)
             {
                 multiplier *= mod.ScoreMultiplier;
-                ranked &= mod.Ranked;
             }
 
             MultiplierLabel.Text = $"{multiplier:N2}x";
@@ -446,8 +437,6 @@ namespace osu.Game.Overlays.Mods
                 MultiplierLabel.FadeColour(LowMultiplierColour, 200);
             else
                 MultiplierLabel.FadeColour(Color4.White, 200);
-
-            UnrankedLabel.FadeTo(ranked ? 0 : 1, 200);
         }
 
         private void updateModSettings(ValueChangedEvent<IReadOnlyList<Mod>> selectedMods)

osu.Game/Overlays/MusicController.cs

@@ -66,7 +66,7 @@ namespace osu.Game.Overlays
             beatmaps.ItemAdded += handleBeatmapAdded;
             beatmaps.ItemRemoved += handleBeatmapRemoved;
 
-            beatmapSets.AddRange(beatmaps.GetAllUsableBeatmapSets().OrderBy(_ => RNG.Next()));
+            beatmapSets.AddRange(beatmaps.GetAllUsableBeatmapSets(IncludedDetails.Minimal).OrderBy(_ => RNG.Next()));
         }
 
         protected override void LoadComplete()
@@ -172,10 +172,15 @@ namespace osu.Game.Overlays
         }
 
         /// <summary>
-        /// Play the previous track or restart the current track if it's current time below <see cref="restart_cutoff_point"/>
+        /// Play the previous track or restart the current track if it's current time below <see cref="restart_cutoff_point"/>.
         /// </summary>
-        /// <returns>The <see cref="PreviousTrackResult"/> that indicate the decided action</returns>
+        public void PreviousTrack() => Schedule(() => prev());
-        public PreviousTrackResult PreviousTrack()
+
+        /// <summary>
+        /// Play the previous track or restart the current track if it's current time below <see cref="restart_cutoff_point"/>.
+        /// </summary>
+        /// <returns>The <see cref="PreviousTrackResult"/> that indicate the decided action.</returns>
+        private PreviousTrackResult prev()
         {
             var currentTrackPosition = current?.Track.CurrentTime;
 
@@ -204,8 +209,7 @@ namespace osu.Game.Overlays
         /// <summary>
         /// Play the next random or playlist track.
         /// </summary>
-        /// <returns>Whether the operation was successful.</returns>
+        public void NextTrack() => Schedule(() => next());
-        public bool NextTrack() => next();
 
         private bool next(bool instant = false)
         {
@@ -319,13 +323,13 @@ namespace osu.Game.Overlays
                     return true;
 
                 case GlobalAction.MusicNext:
-                    if (NextTrack())
+                    if (next())
                         onScreenDisplay?.Display(new MusicControllerToast("Next track"));
 
                     return true;
 
                 case GlobalAction.MusicPrev:
-                    switch (PreviousTrack())
+                    switch (prev())
                     {
                         case PreviousTrackResult.Restart:
                             onScreenDisplay?.Display(new MusicControllerToast("Restart track"));

osu.Game/Screens/Menu/IntroScreen.cs

@@ -73,7 +73,7 @@ namespace osu.Game.Screens.Menu
 
             if (!MenuMusic.Value)
             {
-                var sets = beatmaps.GetAllUsableBeatmapSets();
+                var sets = beatmaps.GetAllUsableBeatmapSets(IncludedDetails.Minimal);
                 if (sets.Count > 0)
                     setInfo = beatmaps.QueryBeatmapSet(s => s.ID == sets[RNG.Next(0, sets.Count - 1)].ID);
             }

osu.Game/Screens/Select/BeatmapCarousel.cs

@@ -169,7 +169,7 @@ namespace osu.Game.Screens.Select
             loadBeatmapSets(GetLoadableBeatmaps());
         }
 
-        protected virtual IEnumerable<BeatmapSetInfo> GetLoadableBeatmaps() => beatmaps.GetAllUsableBeatmapSetsEnumerable();
+        protected virtual IEnumerable<BeatmapSetInfo> GetLoadableBeatmaps() => beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.AllButFiles);
 
         public void RemoveBeatmapSet(BeatmapSetInfo beatmapSet) => Schedule(() =>
         {

osu.Game/Screens/Select/SongSelect.cs

@@ -286,7 +286,7 @@ namespace osu.Game.Screens.Select
                 Schedule(() =>
                 {
                     // if we have no beatmaps but osu-stable is found, let's prompt the user to import.
-                    if (!beatmaps.GetAllUsableBeatmapSetsEnumerable().Any() && beatmaps.StableInstallationAvailable)
+                    if (!beatmaps.GetAllUsableBeatmapSetsEnumerable(IncludedDetails.Minimal).Any() && beatmaps.StableInstallationAvailable)
                     {
                         dialogOverlay.Push(new ImportFromStablePopup(() =>
                         {