Merge branch 'master' into osu-logo-no-update-transforms

osu.Desktop/OsuGameDesktop.cs

@@ -16,6 +16,7 @@ using osu.Framework.Logging;
 using osu.Framework.Screens;
 using osu.Game.Screens.Menu;
 using osu.Game.Updater;
+using osu.Desktop.Windows;
 
 namespace osu.Desktop
 {
@@ -98,6 +99,9 @@ namespace osu.Desktop
                 LoadComponentAsync(versionManager = new VersionManager { Depth = int.MinValue }, Add);
 
             LoadComponentAsync(new DiscordRichPresence(), Add);
+
+            if (RuntimeInfo.OS == RuntimeInfo.Platform.Windows)
+                LoadComponentAsync(new GameplayWinKeyBlocker(), Add);
         }
 
         protected override void ScreenChanged(IScreen lastScreen, IScreen newScreen)

osu.Desktop/Windows/GameplayWinKeyBlocker.cs

@@ -0,0 +1,41 @@
+// 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.Graphics;
+using osu.Framework.Platform;
+using osu.Game.Configuration;
+
+namespace osu.Desktop.Windows
+{
+    public class GameplayWinKeyBlocker : Component
+    {
+        private Bindable<bool> allowScreenSuspension;
+        private Bindable<bool> disableWinKey;
+
+        private GameHost host;
+
+        [BackgroundDependencyLoader]
+        private void load(GameHost host, OsuConfigManager config)
+        {
+            this.host = host;
+
+            allowScreenSuspension = host.AllowScreenSuspension.GetBoundCopy();
+            allowScreenSuspension.BindValueChanged(_ => updateBlocking());
+
+            disableWinKey = config.GetBindable<bool>(OsuSetting.GameplayDisableWinKey);
+            disableWinKey.BindValueChanged(_ => updateBlocking(), true);
+        }
+
+        private void updateBlocking()
+        {
+            bool shouldDisable = disableWinKey.Value && !allowScreenSuspension.Value;
+
+            if (shouldDisable)
+                host.InputThread.Scheduler.Add(WindowsKey.Disable);
+            else
+                host.InputThread.Scheduler.Add(WindowsKey.Enable);
+        }
+    }
+}

osu.Desktop/Windows/WindowsKey.cs

@@ -0,0 +1,80 @@
+// 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.Runtime.InteropServices;
+
+namespace osu.Desktop.Windows
+{
+    internal class WindowsKey
+    {
+        private delegate int LowLevelKeyboardProcDelegate(int nCode, int wParam, ref KdDllHookStruct lParam);
+
+        private static bool isBlocked;
+
+        private const int wh_keyboard_ll = 13;
+        private const int wm_keydown = 256;
+        private const int wm_syskeyup = 261;
+
+        //Resharper disable once NotAccessedField.Local
+        private static LowLevelKeyboardProcDelegate keyboardHookDelegate; // keeping a reference alive for the GC
+        private static IntPtr keyHook;
+
+        [StructLayout(LayoutKind.Explicit)]
+        private readonly struct KdDllHookStruct
+        {
+            [FieldOffset(0)]
+            public readonly int VkCode;
+
+            [FieldOffset(8)]
+            public readonly int Flags;
+        }
+
+        private static int lowLevelKeyboardProc(int nCode, int wParam, ref KdDllHookStruct lParam)
+        {
+            if (wParam >= wm_keydown && wParam <= wm_syskeyup)
+            {
+                switch (lParam.VkCode)
+                {
+                    case 0x5B: // left windows key
+                    case 0x5C: // right windows key
+                        return 1;
+                }
+            }
+
+            return callNextHookEx(0, nCode, wParam, ref lParam);
+        }
+
+        internal static void Disable()
+        {
+            if (keyHook != IntPtr.Zero || isBlocked)
+                return;
+
+            keyHook = setWindowsHookEx(wh_keyboard_ll, (keyboardHookDelegate = lowLevelKeyboardProc), Marshal.GetHINSTANCE(System.Reflection.Assembly.GetExecutingAssembly().GetModules()[0]), 0);
+
+            isBlocked = true;
+        }
+
+        internal static void Enable()
+        {
+            if (keyHook == IntPtr.Zero || !isBlocked)
+                return;
+
+            keyHook = unhookWindowsHookEx(keyHook);
+            keyboardHookDelegate = null;
+
+            keyHook = IntPtr.Zero;
+
+            isBlocked = false;
+        }
+
+        [DllImport(@"user32.dll", EntryPoint = @"SetWindowsHookExA")]
+        private static extern IntPtr setWindowsHookEx(int idHook, LowLevelKeyboardProcDelegate lpfn, IntPtr hMod, int dwThreadId);
+
+        [DllImport(@"user32.dll", EntryPoint = @"UnhookWindowsHookEx")]
+        private static extern IntPtr unhookWindowsHookEx(IntPtr hHook);
+
+        [DllImport(@"user32.dll", EntryPoint = @"CallNextHookEx")]
+        private static extern int callNextHookEx(int hHook, int nCode, int wParam, ref KdDllHookStruct lParam);
+    }
+}

osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs

@@ -78,7 +78,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             if (mods.Any(m => m is ModHidden))
             {
-                value *= 1.05 + 0.075 * (10.0 - Math.Min(10.0, Attributes.ApproachRate)); // 7.5% for each AR below 10
                 // Hiddens gives almost nothing on max approach rate, and more the lower it is
                 if (approachRate <= 10.0)
                     value *= 1.05 + 0.075 * (10.0 - approachRate); // 7.5% for each AR below 10

osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs

@@ -1,26 +1,28 @@
 // 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 System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Utils;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
+using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Replays;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osuTK;
-using System.Collections.Generic;
-using System.Linq;
-using osu.Framework.Graphics.Sprites;
-using osu.Game.Replays;
 using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Storyboards;
+using osu.Game.Tests.Visual;
+using osuTK;
 using static osu.Game.Tests.Visual.OsuTestScene.ClockBackedTestWorkingBeatmap;
 
 namespace osu.Game.Rulesets.Osu.Tests
@@ -34,6 +36,8 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         protected override bool Autoplay => true;
 
+        protected override TestPlayer CreatePlayer(Ruleset ruleset) => new ScoreExposedPlayer();
+
         protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap, Storyboard storyboard = null)
         {
             var working = new ClockBackedTestWorkingBeatmap(beatmap, storyboard, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
@@ -129,18 +133,44 @@ namespace osu.Game.Rulesets.Osu.Tests
                      .ToList()
         };
 
+        [Test]
+        public void TestSpinnerNormalBonusRewinding()
+        {
+            addSeekStep(1000);
+
+            AddAssert("player score matching expected bonus score", () =>
+            {
+                // multipled by 2 to nullify the score multiplier. (autoplay mod selected)
+                var totalScore = ((ScoreExposedPlayer)Player).ScoreProcessor.TotalScore.Value * 2;
+                return totalScore == (int)(drawableSpinner.Disc.CumulativeRotation / 360) * 100;
+            });
+
+            addSeekStep(0);
+
+            AddAssert("player score is 0", () => ((ScoreExposedPlayer)Player).ScoreProcessor.TotalScore.Value == 0);
+        }
+
+        [Test]
+        public void TestSpinnerCompleteBonusRewinding()
+        {
+            addSeekStep(2500);
+            addSeekStep(0);
+
+            AddAssert("player score is 0", () => ((ScoreExposedPlayer)Player).ScoreProcessor.TotalScore.Value == 0);
+        }
+
         [Test]
         public void TestSpinPerMinuteOnRewind()
         {
             double estimatedSpm = 0;
 
-            addSeekStep(2500);
+            addSeekStep(1000);
             AddStep("retrieve spm", () => estimatedSpm = drawableSpinner.SpmCounter.SpinsPerMinute);
 
-            addSeekStep(5000);
+            addSeekStep(2000);
             AddAssert("spm still valid", () => Precision.AlmostEquals(drawableSpinner.SpmCounter.SpinsPerMinute, estimatedSpm, 1.0));
 
-            addSeekStep(2500);
+            addSeekStep(1000);
             AddAssert("spm still valid", () => Precision.AlmostEquals(drawableSpinner.SpmCounter.SpinsPerMinute, estimatedSpm, 1.0));
         }
 
@@ -160,12 +190,17 @@ namespace osu.Game.Rulesets.Osu.Tests
                     Position = new Vector2(256, 192),
                     EndTime = 6000,
                 },
-                // placeholder object to avoid hitting the results screen
-                new HitCircle
-                {
-                    StartTime = 99999,
-                }
             }
         };
+
+        private class ScoreExposedPlayer : TestPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+
+            public ScoreExposedPlayer()
+                : base(false, false)
+            {
+            }
+        }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs

@@ -14,6 +14,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Objects;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Ranking;
@@ -24,9 +25,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
     {
         protected readonly Spinner Spinner;
 
+        private readonly Container<DrawableSpinnerTick> ticks;
+
         public readonly SpinnerDisc Disc;
         public readonly SpinnerTicks Ticks;
         public readonly SpinnerSpmCounter SpmCounter;
+        private readonly SpinnerBonusDisplay bonusDisplay;
 
         private readonly Container mainContainer;
 
@@ -60,6 +64,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             InternalChildren = new Drawable[]
             {
+                ticks = new Container<DrawableSpinnerTick>(),
                 circleContainer = new Container
                 {
                     AutoSizeAxes = Axes.Both,
@@ -120,10 +125,48 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Origin = Anchor.Centre,
                     Y = 120,
                     Alpha = 0
+                },
+                bonusDisplay = new SpinnerBonusDisplay
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Y = -120,
                 }
             };
         }
 
+        protected override void AddNestedHitObject(DrawableHitObject hitObject)
+        {
+            base.AddNestedHitObject(hitObject);
+
+            switch (hitObject)
+            {
+                case DrawableSpinnerTick tick:
+                    ticks.Add(tick);
+                    break;
+            }
+        }
+
+        protected override void ClearNestedHitObjects()
+        {
+            base.ClearNestedHitObjects();
+            ticks.Clear();
+        }
+
+        protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case SpinnerBonusTick bonusTick:
+                    return new DrawableSpinnerBonusTick(bonusTick);
+
+                case SpinnerTick tick:
+                    return new DrawableSpinnerTick(tick);
+            }
+
+            return base.CreateNestedHitObject(hitObject);
+        }
+
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
@@ -156,6 +199,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (userTriggered || Time.Current < Spinner.EndTime)
                 return;
 
+            // Trigger a miss result for remaining ticks to avoid infinite gameplay.
+            foreach (var tick in ticks.Where(t => !t.IsHit))
+                tick.TriggerResult(false);
+
             ApplyResult(r =>
             {
                 if (Progress >= 1)
@@ -185,8 +232,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             circle.Rotation = Disc.Rotation;
             Ticks.Rotation = Disc.Rotation;
+
             SpmCounter.SetRotation(Disc.CumulativeRotation);
 
+            updateBonusScore();
+
             float relativeCircleScale = Spinner.Scale * circle.DrawHeight / mainContainer.DrawHeight;
             float targetScale = relativeCircleScale + (1 - relativeCircleScale) * Progress;
             Disc.Scale = new Vector2((float)Interpolation.Lerp(Disc.Scale.X, targetScale, Math.Clamp(Math.Abs(Time.Elapsed) / 100, 0, 1)));
@@ -194,6 +244,38 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             symbol.Rotation = (float)Interpolation.Lerp(symbol.Rotation, Disc.Rotation / 2, Math.Clamp(Math.Abs(Time.Elapsed) / 40, 0, 1));
         }
 
+        private int wholeSpins;
+
+        private void updateBonusScore()
+        {
+            if (ticks.Count == 0)
+                return;
+
+            int spins = (int)(Disc.CumulativeRotation / 360);
+
+            if (spins < wholeSpins)
+            {
+                // rewinding, silently handle
+                wholeSpins = spins;
+                return;
+            }
+
+            while (wholeSpins != spins)
+            {
+                var tick = ticks.FirstOrDefault(t => !t.IsHit);
+
+                // tick may be null if we've hit the spin limit.
+                if (tick != null)
+                {
+                    tick.TriggerResult(true);
+                    if (tick is DrawableSpinnerBonusTick)
+                        bonusDisplay.SetBonusCount(spins - Spinner.SpinsRequired);
+                }
+
+                wholeSpins++;
+            }
+        }
+
         protected override void UpdateInitialTransforms()
         {
             base.UpdateInitialTransforms();

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerBonusTick.cs

@@ -0,0 +1,13 @@
+// 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.
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class DrawableSpinnerBonusTick : DrawableSpinnerTick
+    {
+        public DrawableSpinnerBonusTick(SpinnerBonusTick spinnerTick)
+            : base(spinnerTick)
+        {
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs

@@ -0,0 +1,23 @@
+// 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.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class DrawableSpinnerTick : DrawableOsuHitObject
+    {
+        public override bool DisplayResult => false;
+
+        public DrawableSpinnerTick(SpinnerTick spinnerTick)
+            : base(spinnerTick)
+        {
+        }
+
+        /// <summary>
+        /// Apply a judgement result.
+        /// </summary>
+        /// <param name="hit">Whether this tick was reached.</param>
+        internal void TriggerResult(bool hit) => ApplyResult(r => r.Type = hit ? r.Judgement.MaxResult : HitResult.Miss);
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusDisplay.cs

@@ -0,0 +1,44 @@
+// 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;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    /// <summary>
+    /// Shows incremental bonus score achieved for a spinner.
+    /// </summary>
+    public class SpinnerBonusDisplay : CompositeDrawable
+    {
+        private readonly OsuSpriteText bonusCounter;
+
+        public SpinnerBonusDisplay()
+        {
+            AutoSizeAxes = Axes.Both;
+
+            InternalChild = bonusCounter = new OsuSpriteText
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Font = OsuFont.Numeric.With(size: 24),
+                Alpha = 0,
+            };
+        }
+
+        private int displayedCount;
+
+        public void SetBonusCount(int count)
+        {
+            if (displayedCount == count)
+                return;
+
+            displayedCount = count;
+            bonusCounter.Text = $"{1000 * count}";
+            bonusCounter.FadeOutFromOne(1500);
+            bonusCounter.ScaleTo(1.5f).Then().ScaleTo(1f, 1000, Easing.OutQuint);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Spinner.cs

@@ -3,9 +3,9 @@
 
 using System;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 
@@ -26,14 +26,43 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         public int SpinsRequired { get; protected set; } = 1;
 
+        /// <summary>
+        /// Number of spins available to give bonus, beyond <see cref="SpinsRequired"/>.
+        /// </summary>
+        public int MaximumBonusSpins { get; protected set; } = 1;
+
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
-            SpinsRequired = (int)(Duration / 1000 * BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5));
-
             // spinning doesn't match 1:1 with stable, so let's fudge them easier for the time being.
-            SpinsRequired = (int)Math.Max(1, SpinsRequired * 0.6);
+            const double stable_matching_fudge = 0.6;
+
+            // close to 477rpm
+            const double maximum_rotations_per_second = 8;
+
+            double secondsDuration = Duration / 1000;
+
+            double minimumRotationsPerSecond = stable_matching_fudge * BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5);
+
+            SpinsRequired = (int)Math.Max(1, (secondsDuration * minimumRotationsPerSecond));
+            MaximumBonusSpins = (int)((maximum_rotations_per_second - minimumRotationsPerSecond) * secondsDuration);
+        }
+
+        protected override void CreateNestedHitObjects()
+        {
+            base.CreateNestedHitObjects();
+
+            int totalSpins = MaximumBonusSpins + SpinsRequired;
+
+            for (int i = 0; i < totalSpins; i++)
+            {
+                double startTime = StartTime + (float)(i + 1) / totalSpins * Duration;
+
+                AddNested(i < SpinsRequired
+                    ? new SpinnerTick { StartTime = startTime }
+                    : new SpinnerBonusTick { StartTime = startTime });
+            }
         }
 
         public override Judgement CreateJudgement() => new OsuJudgement();

osu.Game.Rulesets.Osu/Objects/SpinnerBonusTick.cs

@@ -0,0 +1,26 @@
+// 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.Game.Audio;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Objects
+{
+    public class SpinnerBonusTick : SpinnerTick
+    {
+        public SpinnerBonusTick()
+        {
+            Samples.Add(new HitSampleInfo { Name = "spinnerbonus" });
+        }
+
+        public override Judgement CreateJudgement() => new OsuSpinnerBonusTickJudgement();
+
+        public class OsuSpinnerBonusTickJudgement : OsuSpinnerTickJudgement
+        {
+            protected override int NumericResultFor(HitResult result) => 1100;
+
+            protected override double HealthIncreaseFor(HitResult result) => base.HealthIncreaseFor(result) * 2;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs

@@ -0,0 +1,25 @@
+// 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.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Objects
+{
+    public class SpinnerTick : OsuHitObject
+    {
+        public override Judgement CreateJudgement() => new OsuSpinnerTickJudgement();
+
+        protected override HitWindows CreateHitWindows() => HitWindows.Empty;
+
+        public class OsuSpinnerTickJudgement : OsuJudgement
+        {
+            public override bool AffectsCombo => false;
+
+            protected override int NumericResultFor(HitResult result) => 100;
+
+            protected override double HealthIncreaseFor(HitResult result) => result == MaxResult ? 0.6 * base.HealthIncreaseFor(result) : 0;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Replays
         /// </summary>
         protected static readonly Vector2 SPINNER_CENTRE = OsuPlayfield.BASE_SIZE / 2;
 
-        protected const float SPIN_RADIUS = 50;
+        public const float SPIN_RADIUS = 50;
 
         /// <summary>
         /// The time in ms between each ReplayFrame.

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

@@ -8,6 +8,7 @@ using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Animations;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
@@ -36,6 +37,10 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         private TaikoScoreProcessor scoreProcessor;
 
         private IEnumerable<DrawableTaikoMascot> mascots => this.ChildrenOfType<DrawableTaikoMascot>();
+
+        private IEnumerable<DrawableTaikoMascot> animatedMascots =>
+            mascots.Where(mascot => mascot.ChildrenOfType<TextureAnimation>().All(animation => animation.FrameCount > 0));
+
         private IEnumerable<TaikoPlayfield> playfields => this.ChildrenOfType<TaikoPlayfield>();
 
         [SetUp]
@@ -72,11 +77,11 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
 
             AddStep("set clear state", () => mascots.ForEach(mascot => mascot.State.Value = TaikoMascotAnimationState.Clear));
             AddStep("miss", () => mascots.ForEach(mascot => mascot.LastResult.Value = new JudgementResult(new Hit(), new TaikoJudgement()) { Type = HitResult.Miss }));
-            AddAssert("skins with animations remain in clear state", () => someMascotsIn(TaikoMascotAnimationState.Clear));
+            AddAssert("skins with animations remain in clear state", () => animatedMascotsIn(TaikoMascotAnimationState.Clear));
             AddUntilStep("state reverts to fail", () => allMascotsIn(TaikoMascotAnimationState.Fail));
 
             AddStep("set clear state again", () => mascots.ForEach(mascot => mascot.State.Value = TaikoMascotAnimationState.Clear));
-            AddAssert("skins with animations change to clear", () => someMascotsIn(TaikoMascotAnimationState.Clear));
+            AddAssert("skins with animations change to clear", () => animatedMascotsIn(TaikoMascotAnimationState.Clear));
         }
 
         [Test]
@@ -186,10 +191,18 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
 
         private void assertStateAfterResult(JudgementResult judgementResult, TaikoMascotAnimationState expectedState)
         {
-            AddStep($"{judgementResult.Type.ToString().ToLower()} result for {judgementResult.Judgement.GetType().Name.Humanize(LetterCasing.LowerCase)}",
+            TaikoMascotAnimationState[] mascotStates = null;
-                () => applyNewResult(judgementResult));
 
-            AddAssert($"state is {expectedState.ToString().ToLower()}", () => allMascotsIn(expectedState));
+            AddStep($"{judgementResult.Type.ToString().ToLower()} result for {judgementResult.Judgement.GetType().Name.Humanize(LetterCasing.LowerCase)}",
+                () =>
+                {
+                    applyNewResult(judgementResult);
+                    // store the states as soon as possible, so that the delay between steps doesn't incorrectly fail the test
+                    // due to not checking if the state changed quickly enough.
+                    Schedule(() => mascotStates = animatedMascots.Select(mascot => mascot.State.Value).ToArray());
+                });
+
+            AddAssert($"state is {expectedState.ToString().ToLower()}", () => mascotStates.All(state => state == expectedState));
         }
 
         private void applyNewResult(JudgementResult judgementResult)
@@ -211,6 +224,6 @@ namespace osu.Game.Rulesets.Taiko.Tests.Skinning
         }
 
         private bool allMascotsIn(TaikoMascotAnimationState state) => mascots.All(d => d.State.Value == state);
-        private bool someMascotsIn(TaikoMascotAnimationState state) => mascots.Any(d => d.State.Value == state);
+        private bool animatedMascotsIn(TaikoMascotAnimationState state) => animatedMascots.Any(d => d.State.Value == state);
     }
 }

osu.Game.Rulesets.Taiko/Audio/DrumSampleContainer.cs

@@ -0,0 +1,64 @@
+// 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 osu.Framework.Graphics.Containers;
+using osu.Game.Audio;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Skinning;
+
+namespace osu.Game.Rulesets.Taiko.Audio
+{
+    /// <summary>
+    /// Stores samples for the input drum.
+    /// The lifetime of the samples is adjusted so that they are only alive during the appropriate sample control point.
+    /// </summary>
+    public class DrumSampleContainer : LifetimeManagementContainer
+    {
+        private readonly ControlPointInfo controlPoints;
+        private readonly Dictionary<double, DrumSample> mappings = new Dictionary<double, DrumSample>();
+
+        public DrumSampleContainer(ControlPointInfo controlPoints)
+        {
+            this.controlPoints = controlPoints;
+
+            IReadOnlyList<SampleControlPoint> samplePoints = controlPoints.SamplePoints.Count == 0 ? new[] { controlPoints.SamplePointAt(double.MinValue) } : controlPoints.SamplePoints;
+
+            for (int i = 0; i < samplePoints.Count; i++)
+            {
+                var samplePoint = samplePoints[i];
+
+                var centre = samplePoint.GetSampleInfo();
+                var rim = samplePoint.GetSampleInfo(HitSampleInfo.HIT_CLAP);
+
+                var lifetimeStart = i > 0 ? samplePoint.Time : double.MinValue;
+                var lifetimeEnd = i + 1 < samplePoints.Count ? samplePoints[i + 1].Time : double.MaxValue;
+
+                mappings[samplePoint.Time] = new DrumSample
+                {
+                    Centre = addSound(centre, lifetimeStart, lifetimeEnd),
+                    Rim = addSound(rim, lifetimeStart, lifetimeEnd)
+                };
+            }
+        }
+
+        private SkinnableSound addSound(HitSampleInfo hitSampleInfo, double lifetimeStart, double lifetimeEnd)
+        {
+            var drawable = new SkinnableSound(hitSampleInfo)
+            {
+                LifetimeStart = lifetimeStart,
+                LifetimeEnd = lifetimeEnd
+            };
+            AddInternal(drawable);
+            return drawable;
+        }
+
+        public DrumSample SampleAt(double time) => mappings[controlPoints.SamplePointAt(time).Time];
+
+        public class DrumSample
+        {
+            public SkinnableSound Centre;
+            public SkinnableSound Rim;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Audio/DrumSampleMapping.cs

@@ -1,52 +0,0 @@
-// 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 osu.Game.Audio;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Skinning;
-
-namespace osu.Game.Rulesets.Taiko.Audio
-{
-    public class DrumSampleMapping
-    {
-        private readonly ControlPointInfo controlPoints;
-        private readonly Dictionary<double, DrumSample> mappings = new Dictionary<double, DrumSample>();
-
-        public readonly List<SkinnableSound> Sounds = new List<SkinnableSound>();
-
-        public DrumSampleMapping(ControlPointInfo controlPoints)
-        {
-            this.controlPoints = controlPoints;
-
-            IEnumerable<SampleControlPoint> samplePoints = controlPoints.SamplePoints.Count == 0 ? new[] { controlPoints.SamplePointAt(double.MinValue) } : controlPoints.SamplePoints;
-
-            foreach (var s in samplePoints)
-            {
-                var centre = s.GetSampleInfo();
-                var rim = s.GetSampleInfo(HitSampleInfo.HIT_CLAP);
-
-                mappings[s.Time] = new DrumSample
-                {
-                    Centre = addSound(centre),
-                    Rim = addSound(rim)
-                };
-            }
-        }
-
-        private SkinnableSound addSound(HitSampleInfo hitSampleInfo)
-        {
-            var drawable = new SkinnableSound(hitSampleInfo);
-            Sounds.Add(drawable);
-            return drawable;
-        }
-
-        public DrumSample SampleAt(double time) => mappings[controlPoints.SamplePointAt(time).Time];
-
-        public class DrumSample
-        {
-            public SkinnableSound Centre;
-            public SkinnableSound Rim;
-        }
-    }
-}

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

@@ -111,7 +111,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning
             public readonly Sprite Centre;
 
             [Resolved]
-            private DrumSampleMapping sampleMappings { get; set; }
+            private DrumSampleContainer sampleContainer { get; set; }
 
             public LegacyHalfDrum(bool flipped)
             {
@@ -143,7 +143,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning
             public bool OnPressed(TaikoAction action)
             {
                 Drawable target = null;
-                var drumSample = sampleMappings.SampleAt(Time.Current);
+                var drumSample = sampleContainer.SampleAt(Time.Current);
 
                 if (action == CentreAction)
                 {

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

@@ -91,10 +91,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning
                     return null;
 
                 case TaikoSkinComponents.Mascot:
-                    if (GetTexture("pippidonclear0") != null)
+                    return new DrawableTaikoMascot();
-                        return new DrawableTaikoMascot();
-
-                    return null;
             }
 
             return Source.GetDrawableComponent(component);

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

@@ -25,11 +25,11 @@ namespace osu.Game.Rulesets.Taiko.UI
         private const float middle_split = 0.025f;
 
         [Cached]
-        private DrumSampleMapping sampleMapping;
+        private DrumSampleContainer sampleContainer;
 
         public InputDrum(ControlPointInfo controlPoints)
         {
-            sampleMapping = new DrumSampleMapping(controlPoints);
+            sampleContainer = new DrumSampleContainer(controlPoints);
 
             RelativeSizeAxes = Axes.Both;
         }
@@ -37,39 +37,41 @@ namespace osu.Game.Rulesets.Taiko.UI
         [BackgroundDependencyLoader]
         private void load()
         {
-            Child = new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.InputDrum), _ => new Container
+            Children = new Drawable[]
             {
-                RelativeSizeAxes = Axes.Both,
+                new SkinnableDrawable(new TaikoSkinComponent(TaikoSkinComponents.InputDrum), _ => new Container
-                FillMode = FillMode.Fit,
-                Scale = new Vector2(0.9f),
-                Children = new Drawable[]
                 {
-                    new TaikoHalfDrum(false)
+                    RelativeSizeAxes = Axes.Both,
+                    FillMode = FillMode.Fit,
+                    Scale = new Vector2(0.9f),
+                    Children = new Drawable[]
                     {
-                        Name = "Left Half",
+                        new TaikoHalfDrum(false)
-                        Anchor = Anchor.Centre,
+                        {
-                        Origin = Anchor.CentreRight,
+                            Name = "Left Half",
-                        RelativeSizeAxes = Axes.Both,
+                            Anchor = Anchor.Centre,
-                        RelativePositionAxes = Axes.X,
+                            Origin = Anchor.CentreRight,
-                        X = -middle_split / 2,
+                            RelativeSizeAxes = Axes.Both,
-                        RimAction = TaikoAction.LeftRim,
+                            RelativePositionAxes = Axes.X,
-                        CentreAction = TaikoAction.LeftCentre
+                            X = -middle_split / 2,
-                    },
+                            RimAction = TaikoAction.LeftRim,
-                    new TaikoHalfDrum(true)
+                            CentreAction = TaikoAction.LeftCentre
-                    {
+                        },
-                        Name = "Right Half",
+                        new TaikoHalfDrum(true)
-                        Anchor = Anchor.Centre,
+                        {
-                        Origin = Anchor.CentreLeft,
+                            Name = "Right Half",
-                        RelativeSizeAxes = Axes.Both,
+                            Anchor = Anchor.Centre,
-                        RelativePositionAxes = Axes.X,
+                            Origin = Anchor.CentreLeft,
-                        X = middle_split / 2,
+                            RelativeSizeAxes = Axes.Both,
-                        RimAction = TaikoAction.RightRim,
+                            RelativePositionAxes = Axes.X,
-                        CentreAction = TaikoAction.RightCentre
+                            X = middle_split / 2,
+                            RimAction = TaikoAction.RightRim,
+                            CentreAction = TaikoAction.RightCentre
+                        }
                     }
-                }
+                }),
-            });
+                sampleContainer
-
+            };
-            AddRangeInternal(sampleMapping.Sounds);
         }
 
         /// <summary>
@@ -93,7 +95,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             private readonly Sprite centreHit;
 
             [Resolved]
-            private DrumSampleMapping sampleMappings { get; set; }
+            private DrumSampleContainer sampleContainer { get; set; }
 
             public TaikoHalfDrum(bool flipped)
             {
@@ -154,7 +156,7 @@ namespace osu.Game.Rulesets.Taiko.UI
                 Drawable target = null;
                 Drawable back = null;
 
-                var drumSample = sampleMappings.SampleAt(Time.Current);
+                var drumSample = sampleContainer.SampleAt(Time.Current);
 
                 if (action == CentreAction)
                 {

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

@@ -128,6 +128,13 @@ namespace osu.Game.Rulesets.Taiko.UI
         }
 
         private static Texture getAnimationFrame(ISkin skin, TaikoMascotAnimationState state, int frameIndex)
-            => skin.GetTexture($"pippidon{state.ToString().ToLower()}{frameIndex}");
+        {
+            var texture = skin.GetTexture($"pippidon{state.ToString().ToLower()}{frameIndex}");
+
+            if (frameIndex == 0 && texture == null)
+                texture = skin.GetTexture($"pippidon{state.ToString().ToLower()}");
+
+            return texture;
+        }
     }
 }

osu.Game/Beatmaps/BeatmapDifficultyManager.cs

@@ -0,0 +1,278 @@
+// 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.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Lists;
+using osu.Framework.Threading;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Beatmaps
+{
+    public class BeatmapDifficultyManager : CompositeDrawable
+    {
+        // Too many simultaneous updates can lead to stutters. One thread seems to work fine for song select display purposes.
+        private readonly ThreadedTaskScheduler updateScheduler = new ThreadedTaskScheduler(1, nameof(BeatmapDifficultyManager));
+
+        // A permanent cache to prevent re-computations.
+        private readonly ConcurrentDictionary<DifficultyCacheLookup, StarDifficulty> difficultyCache = new ConcurrentDictionary<DifficultyCacheLookup, StarDifficulty>();
+
+        // All bindables that should be updated along with the current ruleset + mods.
+        private readonly LockedWeakList<BindableStarDifficulty> trackedBindables = new LockedWeakList<BindableStarDifficulty>();
+
+        [Resolved]
+        private BeatmapManager beatmapManager { get; set; }
+
+        [Resolved]
+        private Bindable<RulesetInfo> currentRuleset { get; set; }
+
+        [Resolved]
+        private Bindable<IReadOnlyList<Mod>> currentMods { get; set; }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            currentRuleset.BindValueChanged(_ => updateTrackedBindables());
+            currentMods.BindValueChanged(_ => updateTrackedBindables(), true);
+        }
+
+        /// <summary>
+        /// Retrieves a bindable containing the star difficulty of a <see cref="BeatmapInfo"/> that follows the currently-selected ruleset and mods.
+        /// </summary>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> to get the difficulty of.</param>
+        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> which stops updating the star difficulty for the given <see cref="BeatmapInfo"/>.</param>
+        /// <returns>A bindable that is updated to contain the star difficulty when it becomes available.</returns>
+        public IBindable<StarDifficulty> GetBindableDifficulty([NotNull] BeatmapInfo beatmapInfo, CancellationToken cancellationToken = default)
+        {
+            var bindable = createBindable(beatmapInfo, currentRuleset.Value, currentMods.Value, cancellationToken);
+            trackedBindables.Add(bindable);
+            return bindable;
+        }
+
+        /// <summary>
+        /// Retrieves a bindable containing the star difficulty of a <see cref="BeatmapInfo"/> with a given <see cref="RulesetInfo"/> and <see cref="Mod"/> combination.
+        /// </summary>
+        /// <remarks>
+        /// The bindable will not update to follow the currently-selected ruleset and mods.
+        /// </remarks>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> to get the difficulty of.</param>
+        /// <param name="rulesetInfo">The <see cref="RulesetInfo"/> to get the difficulty with. If <c>null</c>, the <paramref name="beatmapInfo"/>'s ruleset is used.</param>
+        /// <param name="mods">The <see cref="Mod"/>s to get the difficulty with. If <c>null</c>, no mods will be assumed.</param>
+        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> which stops updating the star difficulty for the given <see cref="BeatmapInfo"/>.</param>
+        /// <returns>A bindable that is updated to contain the star difficulty when it becomes available.</returns>
+        public IBindable<StarDifficulty> GetBindableDifficulty([NotNull] BeatmapInfo beatmapInfo, [CanBeNull] RulesetInfo rulesetInfo, [CanBeNull] IEnumerable<Mod> mods,
+                                                               CancellationToken cancellationToken = default)
+            => createBindable(beatmapInfo, rulesetInfo, mods, cancellationToken);
+
+        /// <summary>
+        /// Retrieves the difficulty of a <see cref="BeatmapInfo"/>.
+        /// </summary>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> to get the difficulty of.</param>
+        /// <param name="rulesetInfo">The <see cref="RulesetInfo"/> to get the difficulty with.</param>
+        /// <param name="mods">The <see cref="Mod"/>s to get the difficulty with.</param>
+        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> which stops computing the star difficulty.</param>
+        /// <returns>The <see cref="StarDifficulty"/>.</returns>
+        public async Task<StarDifficulty> GetDifficultyAsync([NotNull] BeatmapInfo beatmapInfo, [CanBeNull] RulesetInfo rulesetInfo = null, [CanBeNull] IEnumerable<Mod> mods = null,
+                                                             CancellationToken cancellationToken = default)
+        {
+            if (tryGetExisting(beatmapInfo, rulesetInfo, mods, out var existing, out var key))
+                return existing;
+
+            return await Task.Factory.StartNew(() => computeDifficulty(key, beatmapInfo, rulesetInfo), cancellationToken,
+                TaskCreationOptions.HideScheduler | TaskCreationOptions.RunContinuationsAsynchronously, updateScheduler);
+        }
+
+        /// <summary>
+        /// Retrieves the difficulty of a <see cref="BeatmapInfo"/>.
+        /// </summary>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> to get the difficulty of.</param>
+        /// <param name="rulesetInfo">The <see cref="RulesetInfo"/> to get the difficulty with.</param>
+        /// <param name="mods">The <see cref="Mod"/>s to get the difficulty with.</param>
+        /// <returns>The <see cref="StarDifficulty"/>.</returns>
+        public StarDifficulty GetDifficulty([NotNull] BeatmapInfo beatmapInfo, [CanBeNull] RulesetInfo rulesetInfo = null, [CanBeNull] IEnumerable<Mod> mods = null)
+        {
+            if (tryGetExisting(beatmapInfo, rulesetInfo, mods, out var existing, out var key))
+                return existing;
+
+            return computeDifficulty(key, beatmapInfo, rulesetInfo);
+        }
+
+        private CancellationTokenSource trackedUpdateCancellationSource;
+
+        /// <summary>
+        /// Updates all tracked <see cref="BindableStarDifficulty"/> using the current ruleset and mods.
+        /// </summary>
+        private void updateTrackedBindables()
+        {
+            trackedUpdateCancellationSource?.Cancel();
+            trackedUpdateCancellationSource = new CancellationTokenSource();
+
+            foreach (var b in trackedBindables)
+            {
+                if (trackedUpdateCancellationSource.IsCancellationRequested)
+                    break;
+
+                using (var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(trackedUpdateCancellationSource.Token, b.CancellationToken))
+                    updateBindable(b, currentRuleset.Value, currentMods.Value, linkedSource.Token);
+            }
+        }
+
+        /// <summary>
+        /// Updates the value of a <see cref="BindableStarDifficulty"/> with a given ruleset + mods.
+        /// </summary>
+        /// <param name="bindable">The <see cref="BindableStarDifficulty"/> to update.</param>
+        /// <param name="rulesetInfo">The <see cref="RulesetInfo"/> to update with.</param>
+        /// <param name="mods">The <see cref="Mod"/>s to update with.</param>
+        /// <param name="cancellationToken">A token that may be used to cancel this update.</param>
+        private void updateBindable([NotNull] BindableStarDifficulty bindable, [CanBeNull] RulesetInfo rulesetInfo, [CanBeNull] IEnumerable<Mod> mods, CancellationToken cancellationToken = default)
+        {
+            GetDifficultyAsync(bindable.Beatmap, rulesetInfo, mods, cancellationToken).ContinueWith(t =>
+            {
+                // We're on a threadpool thread, but we should exit back to the update thread so consumers can safely handle value-changed events.
+                Schedule(() =>
+                {
+                    if (!cancellationToken.IsCancellationRequested)
+                        bindable.Value = t.Result;
+                });
+            }, cancellationToken);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="BindableStarDifficulty"/> and triggers an initial value update.
+        /// </summary>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> that star difficulty should correspond to.</param>
+        /// <param name="initialRulesetInfo">The initial <see cref="RulesetInfo"/> to get the difficulty with.</param>
+        /// <param name="initialMods">The initial <see cref="Mod"/>s to get the difficulty with.</param>
+        /// <param name="cancellationToken">An optional <see cref="CancellationToken"/> which stops updating the star difficulty for the given <see cref="BeatmapInfo"/>.</param>
+        /// <returns>The <see cref="BindableStarDifficulty"/>.</returns>
+        private BindableStarDifficulty createBindable([NotNull] BeatmapInfo beatmapInfo, [CanBeNull] RulesetInfo initialRulesetInfo, [CanBeNull] IEnumerable<Mod> initialMods,
+                                                      CancellationToken cancellationToken)
+        {
+            var bindable = new BindableStarDifficulty(beatmapInfo, cancellationToken);
+            updateBindable(bindable, initialRulesetInfo, initialMods, cancellationToken);
+            return bindable;
+        }
+
+        /// <summary>
+        /// Computes the difficulty defined by a <see cref="DifficultyCacheLookup"/> key, and stores it to the timed cache.
+        /// </summary>
+        /// <param name="key">The <see cref="DifficultyCacheLookup"/> that defines the computation parameters.</param>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/> to compute the difficulty of.</param>
+        /// <param name="rulesetInfo">The <see cref="RulesetInfo"/> to compute the difficulty with.</param>
+        /// <returns>The <see cref="StarDifficulty"/>.</returns>
+        private StarDifficulty computeDifficulty(in DifficultyCacheLookup key, BeatmapInfo beatmapInfo, RulesetInfo rulesetInfo)
+        {
+            // In the case that the user hasn't given us a ruleset, use the beatmap's default ruleset.
+            rulesetInfo ??= beatmapInfo.Ruleset;
+
+            try
+            {
+                var ruleset = rulesetInfo.CreateInstance();
+                Debug.Assert(ruleset != null);
+
+                var calculator = ruleset.CreateDifficultyCalculator(beatmapManager.GetWorkingBeatmap(beatmapInfo));
+                var attributes = calculator.Calculate(key.Mods);
+
+                return difficultyCache[key] = new StarDifficulty(attributes.StarRating);
+            }
+            catch
+            {
+                return difficultyCache[key] = new StarDifficulty(0);
+            }
+        }
+
+        /// <summary>
+        /// Attempts to retrieve an existing difficulty for the combination.
+        /// </summary>
+        /// <param name="beatmapInfo">The <see cref="BeatmapInfo"/>.</param>
+        /// <param name="rulesetInfo">The <see cref="RulesetInfo"/>.</param>
+        /// <param name="mods">The <see cref="Mod"/>s.</param>
+        /// <param name="existingDifficulty">The existing difficulty value, if present.</param>
+        /// <param name="key">The <see cref="DifficultyCacheLookup"/> key that was used to perform this lookup. This can be further used to query <see cref="computeDifficulty"/>.</param>
+        /// <returns>Whether an existing difficulty was found.</returns>
+        private bool tryGetExisting(BeatmapInfo beatmapInfo, RulesetInfo rulesetInfo, IEnumerable<Mod> mods, out StarDifficulty existingDifficulty, out DifficultyCacheLookup key)
+        {
+            // In the case that the user hasn't given us a ruleset, use the beatmap's default ruleset.
+            rulesetInfo ??= beatmapInfo.Ruleset;
+
+            // Difficulty can only be computed if the beatmap and ruleset are locally available.
+            if (beatmapInfo.ID == 0 || rulesetInfo.ID == null)
+            {
+                // If not, fall back to the existing star difficulty (e.g. from an online source).
+                existingDifficulty = new StarDifficulty(beatmapInfo.StarDifficulty);
+                key = default;
+
+                return true;
+            }
+
+            key = new DifficultyCacheLookup(beatmapInfo.ID, rulesetInfo.ID.Value, mods);
+            return difficultyCache.TryGetValue(key, out existingDifficulty);
+        }
+
+        private readonly struct DifficultyCacheLookup : IEquatable<DifficultyCacheLookup>
+        {
+            public readonly int BeatmapId;
+            public readonly int RulesetId;
+            public readonly Mod[] Mods;
+
+            public DifficultyCacheLookup(int beatmapId, int rulesetId, IEnumerable<Mod> mods)
+            {
+                BeatmapId = beatmapId;
+                RulesetId = rulesetId;
+                Mods = mods?.OrderBy(m => m.Acronym).ToArray() ?? Array.Empty<Mod>();
+            }
+
+            public bool Equals(DifficultyCacheLookup other)
+                => BeatmapId == other.BeatmapId
+                   && RulesetId == other.RulesetId
+                   && Mods.SequenceEqual(other.Mods);
+
+            public override int GetHashCode()
+            {
+                var hashCode = new HashCode();
+
+                hashCode.Add(BeatmapId);
+                hashCode.Add(RulesetId);
+                foreach (var mod in Mods)
+                    hashCode.Add(mod.Acronym);
+
+                return hashCode.ToHashCode();
+            }
+        }
+
+        private class BindableStarDifficulty : Bindable<StarDifficulty>
+        {
+            public readonly BeatmapInfo Beatmap;
+            public readonly CancellationToken CancellationToken;
+
+            public BindableStarDifficulty(BeatmapInfo beatmap, CancellationToken cancellationToken)
+            {
+                Beatmap = beatmap;
+                CancellationToken = cancellationToken;
+            }
+        }
+    }
+
+    public readonly struct StarDifficulty
+    {
+        public readonly double Stars;
+
+        public StarDifficulty(double stars)
+        {
+            Stars = stars;
+
+            // Todo: Add more members (BeatmapInfo.DifficultyRating? Attributes? Etc...)
+        }
+    }
+}

osu.Game/Configuration/OsuConfigManager.cs

@@ -99,6 +99,7 @@ namespace osu.Game.Configuration
             Set(OsuSetting.ScoreDisplayMode, ScoringMode.Standardised);
 
             Set(OsuSetting.IncreaseFirstObjectVisibility, true);
+            Set(OsuSetting.GameplayDisableWinKey, true);
 
             // Update
             Set(OsuSetting.ReleaseStream, ReleaseStream.Lazer);
@@ -229,6 +230,7 @@ namespace osu.Game.Configuration
         IntroSequence,
         UIHoldActivationDelay,
         HitLighting,
-        MenuBackgroundSource
+        MenuBackgroundSource,
+        GameplayDisableWinKey
     }
 }

osu.Game/Graphics/Cursor/MenuCursorContainer.cs

@@ -1,7 +1,6 @@
 // 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.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
@@ -55,7 +54,16 @@ namespace osu.Game.Graphics.Cursor
                 return;
             }
 
-            var newTarget = inputManager.HoveredDrawables.OfType<IProvideCursor>().FirstOrDefault(t => t.ProvidingUserCursor) ?? this;
+            IProvideCursor newTarget = this;
+
+            foreach (var d in inputManager.HoveredDrawables)
+            {
+                if (d is IProvideCursor p && p.ProvidingUserCursor)
+                {
+                    newTarget = p;
+                    break;
+                }
+            }
 
             if (currentTarget == newTarget)
                 return;

osu.Game/Graphics/ScreenshotManager.cs

@@ -19,6 +19,7 @@ using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Formats.Jpeg;
 
 namespace osu.Game.Graphics
 {
@@ -119,7 +120,9 @@ namespace osu.Game.Graphics
                         break;
 
                     case ScreenshotFormat.Jpg:
-                        image.SaveAsJpeg(stream);
+                        const int jpeg_quality = 92;
+
+                        image.SaveAsJpeg(stream, new JpegEncoder { Quality = jpeg_quality });
                         break;
 
                     default:

osu.Game/OsuGame.cs

@@ -18,6 +18,7 @@ using osu.Game.Screens.Menu;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Humanizer;
 using JetBrains.Annotations;
 using osu.Framework.Audio;
 using osu.Framework.Bindables;
@@ -759,7 +760,7 @@ namespace osu.Game
                     Schedule(() => notifications.Post(new SimpleNotification
                     {
                         Icon = entry.Level == LogLevel.Important ? FontAwesome.Solid.ExclamationCircle : FontAwesome.Solid.Bomb,
-                        Text = entry.Message + (entry.Exception != null && IsDeployedBuild ? "\n\nThis error has been automatically reported to the devs." : string.Empty),
+                        Text = entry.Message.Truncate(256) + (entry.Exception != null && IsDeployedBuild ? "\n\nThis error has been automatically reported to the devs." : string.Empty),
                     }));
                 }
                 else if (recentLogCount == short_term_display_limit)

osu.Game/OsuGameBase.cs

@@ -199,6 +199,10 @@ namespace osu.Game
                     ScoreManager.Undelete(getBeatmapScores(item), true);
             });
 
+            var difficultyManager = new BeatmapDifficultyManager();
+            dependencies.Cache(difficultyManager);
+            AddInternal(difficultyManager);
+
             dependencies.Cache(KeyBindingStore = new KeyBindingStore(contextFactory, RulesetStore));
             dependencies.Cache(SettingsStore = new SettingsStore(contextFactory));
             dependencies.Cache(RulesetConfigCache = new RulesetConfigCache(SettingsStore));

osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.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 osu.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
@@ -78,6 +79,15 @@ namespace osu.Game.Overlays.Settings.Sections.Gameplay
                     Bindable = config.GetBindable<ScoringMode>(OsuSetting.ScoreDisplayMode)
                 }
             };
+
+            if (RuntimeInfo.OS == RuntimeInfo.Platform.Windows)
+            {
+                Add(new SettingsCheckbox
+                {
+                    LabelText = "Disable Windows key during gameplay",
+                    Bindable = config.GetBindable<bool>(OsuSetting.GameplayDisableWinKey)
+                });
+            }
         }
     }
 }

osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs

@@ -129,9 +129,9 @@ namespace osu.Game.Rulesets.Objects.Drawables
             LoadSamples();
         }
 
-        protected override void LoadComplete()
+        protected override void LoadAsyncComplete()
         {
-            base.LoadComplete();
+            base.LoadAsyncComplete();
 
             HitObject.DefaultsApplied += onDefaultsApplied;
 
@@ -148,6 +148,11 @@ namespace osu.Game.Rulesets.Objects.Drawables
             samplesBindable.CollectionChanged += (_, __) => LoadSamples();
 
             apply(HitObject);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
 
             updateState(ArmedState.Idle, true);
         }

osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs

@@ -2,11 +2,13 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Caching;
 using osu.Framework.Graphics;
 using osu.Framework.Layout;
+using osu.Framework.Threading;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osuTK;
@@ -17,7 +19,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
     {
         private readonly IBindable<double> timeRange = new BindableDouble();
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
-        private readonly Dictionary<DrawableHitObject, Cached> hitObjectInitialStateCache = new Dictionary<DrawableHitObject, Cached>();
+        private readonly Dictionary<DrawableHitObject, InitialState> hitObjectInitialStateCache = new Dictionary<DrawableHitObject, InitialState>();
 
         [Resolved]
         private IScrollingInfo scrollingInfo { get; set; }
@@ -175,10 +177,10 @@ namespace osu.Game.Rulesets.UI.Scrolling
         {
             // The cache may not exist if the hitobject state hasn't been computed yet (e.g. if the hitobject was added + defaults applied in the same frame).
             // In such a case, combinedObjCache will take care of updating the hitobject.
-            if (hitObjectInitialStateCache.TryGetValue(drawableObject, out var objCache))
+            if (hitObjectInitialStateCache.TryGetValue(drawableObject, out var state))
             {
                 combinedObjCache.Invalidate();
-                objCache.Invalidate();
+                state.Cache.Invalidate();
             }
         }
 
@@ -190,8 +192,8 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
             if (!layoutCache.IsValid)
             {
-                foreach (var cached in hitObjectInitialStateCache.Values)
+                foreach (var state in hitObjectInitialStateCache.Values)
-                    cached.Invalidate();
+                    state.Cache.Invalidate();
                 combinedObjCache.Invalidate();
 
                 scrollingInfo.Algorithm.Reset();
@@ -215,16 +217,18 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
                 foreach (var obj in Objects)
                 {
-                    if (!hitObjectInitialStateCache.TryGetValue(obj, out var objCache))
+                    if (!hitObjectInitialStateCache.TryGetValue(obj, out var state))
-                        objCache = hitObjectInitialStateCache[obj] = new Cached();
+                        state = hitObjectInitialStateCache[obj] = new InitialState(new Cached());
 
-                    if (objCache.IsValid)
+                    if (state.Cache.IsValid)
                         continue;
 
-                    computeLifetimeStartRecursive(obj);
+                    state.ScheduledComputation?.Cancel();
-                    computeInitialStateRecursive(obj);
+                    state.ScheduledComputation = computeInitialStateRecursive(obj);
 
-                    objCache.Validate();
+                    computeLifetimeStartRecursive(obj);
+
+                    state.Cache.Validate();
                 }
 
                 combinedObjCache.Validate();
@@ -267,8 +271,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
             return scrollingInfo.Algorithm.GetDisplayStartTime(hitObject.HitObject.StartTime, originAdjustment, timeRange.Value, scrollLength);
         }
 
-        // Cant use AddOnce() since the delegate is re-constructed every invocation
+        private ScheduledDelegate computeInitialStateRecursive(DrawableHitObject hitObject) => hitObject.Schedule(() =>
-        private void computeInitialStateRecursive(DrawableHitObject hitObject) => hitObject.Schedule(() =>
         {
             if (hitObject.HitObject is IHasDuration e)
             {
@@ -325,5 +328,19 @@ namespace osu.Game.Rulesets.UI.Scrolling
                     break;
             }
         }
+
+        private class InitialState
+        {
+            [NotNull]
+            public readonly Cached Cache;
+
+            [CanBeNull]
+            public ScheduledDelegate ScheduledComputation;
+
+            public InitialState(Cached cache)
+            {
+                Cache = cache;
+            }
+        }
     }
 }

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

@@ -3,7 +3,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
@@ -41,6 +43,12 @@ namespace osu.Game.Screens.Select.Carousel
         [Resolved(CanBeNull = true)]
         private BeatmapSetOverlay beatmapOverlay { get; set; }
 
+        [Resolved]
+        private BeatmapDifficultyManager difficultyManager { get; set; }
+
+        private IBindable<StarDifficulty> starDifficultyBindable;
+        private CancellationTokenSource starDifficultyCancellationSource;
+
         public DrawableCarouselBeatmap(CarouselBeatmap panel)
             : base(panel)
         {
@@ -137,7 +145,6 @@ namespace osu.Game.Screens.Select.Carousel
                                         },
                                         starCounter = new StarCounter
                                         {
-                                            Current = (float)beatmap.StarDifficulty,
                                             Scale = new Vector2(0.8f),
                                         }
                                     }
@@ -181,6 +188,16 @@ namespace osu.Game.Screens.Select.Carousel
             if (Item.State.Value != CarouselItemState.Collapsed && Alpha == 0)
                 starCounter.ReplayAnimation();
 
+            starDifficultyCancellationSource?.Cancel();
+
+            // Only compute difficulty when the item is visible.
+            if (Item.State.Value != CarouselItemState.Collapsed)
+            {
+                // We've potentially cancelled the computation above so a new bindable is required.
+                starDifficultyBindable = difficultyManager.GetBindableDifficulty(beatmap, (starDifficultyCancellationSource = new CancellationTokenSource()).Token);
+                starDifficultyBindable.BindValueChanged(d => starCounter.Current = (float)d.NewValue.Stars, true);
+            }
+
             base.ApplyState();
         }
 
@@ -205,5 +222,11 @@ namespace osu.Game.Screens.Select.Carousel
                 return items.ToArray();
             }
         }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            starDifficultyCancellationSource?.Cancel();
+        }
     }
 }

osu.Game/Screens/Select/Details/AdvancedStats.cs

@@ -14,10 +14,12 @@ using osu.Framework.Bindables;
 using System.Collections.Generic;
 using osu.Game.Rulesets.Mods;
 using System.Linq;
+using System.Threading;
 using osu.Framework.Threading;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets;
 
 namespace osu.Game.Screens.Select.Details
 {
@@ -26,6 +28,12 @@ namespace osu.Game.Screens.Select.Details
         [Resolved]
         private IBindable<IReadOnlyList<Mod>> mods { get; set; }
 
+        [Resolved]
+        private IBindable<RulesetInfo> ruleset { get; set; }
+
+        [Resolved]
+        private BeatmapDifficultyManager difficultyManager { get; set; }
+
         protected readonly StatisticRow FirstValue, HpDrain, Accuracy, ApproachRate;
         private readonly StatisticRow starDifficulty;
 
@@ -71,6 +79,7 @@ namespace osu.Game.Screens.Select.Details
         {
             base.LoadComplete();
 
+            ruleset.BindValueChanged(_ => updateStatistics());
             mods.BindValueChanged(modsChanged, true);
         }
 
@@ -132,11 +141,39 @@ namespace osu.Game.Screens.Select.Details
                     break;
             }
 
-            starDifficulty.Value = ((float)(Beatmap?.StarDifficulty ?? 0), null);
-
             HpDrain.Value = (baseDifficulty?.DrainRate ?? 0, adjustedDifficulty?.DrainRate);
             Accuracy.Value = (baseDifficulty?.OverallDifficulty ?? 0, adjustedDifficulty?.OverallDifficulty);
             ApproachRate.Value = (baseDifficulty?.ApproachRate ?? 0, adjustedDifficulty?.ApproachRate);
+
+            updateStarDifficulty();
+        }
+
+        private IBindable<StarDifficulty> normalStarDifficulty;
+        private IBindable<StarDifficulty> moddedStarDifficulty;
+        private CancellationTokenSource starDifficultyCancellationSource;
+
+        private void updateStarDifficulty()
+        {
+            starDifficultyCancellationSource?.Cancel();
+
+            if (Beatmap == null)
+                return;
+
+            starDifficultyCancellationSource = new CancellationTokenSource();
+
+            normalStarDifficulty = difficultyManager.GetBindableDifficulty(Beatmap, ruleset.Value, null, starDifficultyCancellationSource.Token);
+            moddedStarDifficulty = difficultyManager.GetBindableDifficulty(Beatmap, ruleset.Value, mods.Value, starDifficultyCancellationSource.Token);
+
+            normalStarDifficulty.BindValueChanged(_ => updateDisplay());
+            moddedStarDifficulty.BindValueChanged(_ => updateDisplay(), true);
+
+            void updateDisplay() => starDifficulty.Value = ((float)normalStarDifficulty.Value.Stars, (float)moddedStarDifficulty.Value.Stars);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            starDifficultyCancellationSource?.Cancel();
         }
 
         public class StatisticRow : Container, IHasAccentColour

osu.Game/Skinning/SkinnableSound.cs

@@ -22,6 +22,9 @@ namespace osu.Game.Skinning
         [Resolved]
         private ISampleStore samples { get; set; }
 
+        public override bool RemoveWhenNotAlive => false;
+        public override bool RemoveCompletedTransforms => false;
+
         public SkinnableSound(ISampleInfo hitSamples)
             : this(new[] { hitSamples })
         {