Merge branch 'master' into add-spinner-clear

osu.Android.props

@@ -52,6 +52,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1030.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.1029.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.1105.0" />
   </ItemGroup>
 </Project>

osu.Game.Rulesets.Catch/Mods/CatchModHidden.cs

@@ -17,9 +17,11 @@ namespace osu.Game.Rulesets.Catch.Mods
         private const double fade_out_offset_multiplier = 0.6;
         private const double fade_out_duration_multiplier = 0.44;
 
-        protected override void ApplyHiddenState(DrawableHitObject drawable, ArmedState state)
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
-            if (!(drawable is DrawableCatchHitObject catchDrawable))
+            base.ApplyNormalVisibilityState(hitObject, state);
+
+            if (!(hitObject is DrawableCatchHitObject catchDrawable))
                 return;
 
             if (catchDrawable.NestedHitObjects.Any())

osu.Game.Rulesets.Osu/Mods/OsuModHidden.cs

@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
@@ -23,28 +22,38 @@ namespace osu.Game.Rulesets.Osu.Mods
         private const double fade_in_duration_multiplier = 0.4;
         private const double fade_out_duration_multiplier = 0.3;
 
-        protected override bool IsFirstHideableObject(DrawableHitObject hitObject) => !(hitObject is DrawableSpinner);
+        protected override bool IsFirstAdjustableObject(HitObject hitObject) => !(hitObject is Spinner);
 
         public override void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
         {
-            static void adjustFadeIn(OsuHitObject h) => h.TimeFadeIn = h.TimePreempt * fade_in_duration_multiplier;
+            foreach (var d in drawables)
-
+                d.ApplyCustomUpdateState += applyFadeInAdjustment;
-            foreach (var d in drawables.OfType<DrawableOsuHitObject>())
-            {
-                adjustFadeIn(d.HitObject);
-                foreach (var h in d.HitObject.NestedHitObjects.OfType<OsuHitObject>())
-                    adjustFadeIn(h);
-            }
 
             base.ApplyToDrawableHitObjects(drawables);
         }
 
+        private void applyFadeInAdjustment(DrawableHitObject hitObject, ArmedState state)
+        {
+            if (!(hitObject is DrawableOsuHitObject d))
+                return;
+
+            d.HitObject.TimeFadeIn = d.HitObject.TimePreempt * fade_in_duration_multiplier;
+        }
+
         private double lastSliderHeadFadeOutStartTime;
         private double lastSliderHeadFadeOutDuration;
 
-        protected override void ApplyFirstObjectIncreaseVisibilityState(DrawableHitObject drawable, ArmedState state) => applyState(drawable, true);
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
+        {
+            base.ApplyIncreasedVisibilityState(hitObject, state);
+            applyState(hitObject, true);
+        }
 
-        protected override void ApplyHiddenState(DrawableHitObject drawable, ArmedState state) => applyState(drawable, false);
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
+        {
+            base.ApplyNormalVisibilityState(hitObject, state);
+            applyState(hitObject, false);
+        }
 
         private void applyState(DrawableHitObject drawable, bool increaseVisibility)
         {

osu.Game.Rulesets.Osu/Mods/OsuModObjectScaleTween.cs

@@ -2,11 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -17,7 +14,7 @@ namespace osu.Game.Rulesets.Osu.Mods
     /// <summary>
     /// Adjusts the size of hit objects during their fade in animation.
     /// </summary>
-    public abstract class OsuModObjectScaleTween : Mod, IReadFromConfig, IApplicableToDrawableHitObjects
+    public abstract class OsuModObjectScaleTween : ModWithVisibilityAdjustment
     {
         public override ModType Type => ModType.Fun;
 
@@ -27,33 +24,19 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         protected virtual float EndScale => 1;
 
-        private Bindable<bool> increaseFirstObjectVisibility = new Bindable<bool>();
-
         public override Type[] IncompatibleMods => new[] { typeof(OsuModSpinIn), typeof(OsuModTraceable) };
 
-        public void ReadFromConfig(OsuConfigManager config)
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
-            increaseFirstObjectVisibility = config.GetBindable<bool>(OsuSetting.IncreaseFirstObjectVisibility);
         }
 
-        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyCustomState(hitObject, state);
-        {
-            foreach (var drawable in drawables.Skip(increaseFirstObjectVisibility.Value ? 1 : 0))
-            {
-                switch (drawable)
-                {
-                    case DrawableSpinner _:
-                        continue;
 
-                    default:
+        private void applyCustomState(DrawableHitObject drawable, ArmedState state)
-                        drawable.ApplyCustomUpdateState += ApplyCustomState;
-                        break;
-                }
-            }
-        }
-
-        protected virtual void ApplyCustomState(DrawableHitObject drawable, ArmedState state)
         {
+            if (drawable is DrawableSpinner)
+                return;
+
             var h = (OsuHitObject)drawable.HitObject;
 
             // apply grow effect

osu.Game.Rulesets.Osu/Mods/OsuModSpinIn.cs

@@ -2,12 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
@@ -16,7 +12,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModSpinIn : Mod, IApplicableToDrawableHitObjects, IReadFromConfig
+    public class OsuModSpinIn : ModWithVisibilityAdjustment
     {
         public override string Name => "Spin In";
         public override string Acronym => "SI";
@@ -31,31 +27,17 @@ namespace osu.Game.Rulesets.Osu.Mods
         private const int rotate_offset = 360;
         private const float rotate_starting_width = 2;
 
-        private Bindable<bool> increaseFirstObjectVisibility = new Bindable<bool>();
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
-
-        public void ReadFromConfig(OsuConfigManager config)
         {
-            increaseFirstObjectVisibility = config.GetBindable<bool>(OsuSetting.IncreaseFirstObjectVisibility);
         }
 
-        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyZoomState(hitObject, state);
-        {
-            foreach (var drawable in drawables.Skip(increaseFirstObjectVisibility.Value ? 1 : 0))
-            {
-                switch (drawable)
-                {
-                    case DrawableSpinner _:
-                        continue;
-
-                    default:
-                        drawable.ApplyCustomUpdateState += applyZoomState;
-                        break;
-                }
-            }
-        }
 
         private void applyZoomState(DrawableHitObject drawable, ArmedState state)
         {
+            if (drawable is DrawableSpinner)
+                return;
+
             var h = (OsuHitObject)drawable.HitObject;
 
             switch (drawable)

osu.Game.Rulesets.Osu/Mods/OsuModTraceable.cs

@@ -2,12 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Linq;
-using osu.Framework.Bindables;
-using System.Collections.Generic;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
@@ -15,7 +11,7 @@ using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    internal class OsuModTraceable : Mod, IReadFromConfig, IApplicableToDrawableHitObjects
+    internal class OsuModTraceable : ModWithVisibilityAdjustment
     {
         public override string Name => "Traceable";
         public override string Acronym => "TC";
@@ -24,20 +20,14 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override double ScoreMultiplier => 1;
 
         public override Type[] IncompatibleMods => new[] { typeof(OsuModHidden), typeof(OsuModSpinIn), typeof(OsuModObjectScaleTween) };
-        private Bindable<bool> increaseFirstObjectVisibility = new Bindable<bool>();
 
-        public void ReadFromConfig(OsuConfigManager config)
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
-            increaseFirstObjectVisibility = config.GetBindable<bool>(OsuSetting.IncreaseFirstObjectVisibility);
         }
 
-        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTraceableState(hitObject, state);
-        {
-            foreach (var drawable in drawables.Skip(increaseFirstObjectVisibility.Value ? 1 : 0))
-                drawable.ApplyCustomUpdateState += ApplyTraceableState;
-        }
 
-        protected void ApplyTraceableState(DrawableHitObject drawable, ArmedState state)
+        private void applyTraceableState(DrawableHitObject drawable, ArmedState state)
         {
             if (!(drawable is DrawableOsuHitObject))
                 return;

osu.Game.Rulesets.Osu/Mods/OsuModTransform.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
@@ -13,7 +12,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    internal class OsuModTransform : Mod, IApplicableToDrawableHitObjects
+    internal class OsuModTransform : ModWithVisibilityAdjustment
     {
         public override string Name => "Transform";
         public override string Acronym => "TR";
@@ -25,11 +24,9 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         private float theta;
 
-        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTransform(hitObject, state);
-        {
+
-            foreach (var drawable in drawables)
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => applyTransform(hitObject, state);
-                drawable.ApplyCustomUpdateState += applyTransform;
-        }
 
         private void applyTransform(DrawableHitObject drawable, ArmedState state)
         {

osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.Mods;
@@ -13,7 +12,7 @@ using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    internal class OsuModWiggle : Mod, IApplicableToDrawableHitObjects
+    internal class OsuModWiggle : ModWithVisibilityAdjustment
     {
         public override string Name => "Wiggle";
         public override string Acronym => "WG";
@@ -26,11 +25,9 @@ namespace osu.Game.Rulesets.Osu.Mods
         private const int wiggle_duration = 90; // (ms) Higher = fewer wiggles
         private const int wiggle_strength = 10; // Higher = stronger wiggles
 
-        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state) => drawableOnApplyCustomUpdateState(hitObject, state);
-        {
+
-            foreach (var drawable in drawables)
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state) => drawableOnApplyCustomUpdateState(hitObject, state);
-                drawable.ApplyCustomUpdateState += drawableOnApplyCustomUpdateState;
-        }
 
         private void drawableOnApplyCustomUpdateState(DrawableHitObject drawable, ArmedState state)
         {

osu.Game.Tests/Beatmaps/BeatmapDifficultyManagerTest.cs

@@ -14,8 +14,8 @@ namespace osu.Game.Tests.Beatmaps
         [Test]
         public void TestKeyEqualsWithDifferentModInstances()
         {
-            var key1 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
+            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
-            var key2 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
+            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
 
             Assert.That(key1, Is.EqualTo(key2));
         }
@@ -23,8 +23,8 @@ namespace osu.Game.Tests.Beatmaps
         [Test]
         public void TestKeyEqualsWithDifferentModOrder()
         {
-            var key1 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
+            var key1 = new BeatmapDifficultyCache.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHardRock(), new OsuModHidden() });
-            var key2 = new BeatmapDifficultyManager.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHidden(), new OsuModHardRock() });
+            var key2 = new BeatmapDifficultyCache.DifficultyCacheLookup(1234, 0, new Mod[] { new OsuModHidden(), new OsuModHardRock() });
 
             Assert.That(key1, Is.EqualTo(key2));
         }
@@ -47,7 +47,7 @@ namespace osu.Game.Tests.Beatmaps
         [TestCase(8.3, DifficultyRating.ExpertPlus)]
         public void TestDifficultyRatingMapping(double starRating, DifficultyRating expectedBracket)
         {
-            var actualBracket = BeatmapDifficultyManager.GetDifficultyRating(starRating);
+            var actualBracket = BeatmapDifficultyCache.GetDifficultyRating(starRating);
 
             Assert.AreEqual(expectedBracket, actualBracket);
         }

osu.Game.Tests/Visual/Gameplay/TestSceneSpectator.cs

@@ -250,7 +250,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public void EndPlay(int beatmapId)
             {
-                ((ISpectatorClient)this).UserFinishedPlaying((int)StreamingUser.Id, new SpectatorState
+                ((ISpectatorClient)this).UserFinishedPlaying(StreamingUser.Id, new SpectatorState
                 {
                     BeatmapID = beatmapId,
                     RulesetID = 0,
@@ -273,7 +273,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                 }
 
                 var bundle = new FrameDataBundle(frames);
-                ((ISpectatorClient)this).UserSentFrames((int)StreamingUser.Id, bundle);
+                ((ISpectatorClient)this).UserSentFrames(StreamingUser.Id, bundle);
 
                 if (!sentState)
                     sendState(beatmapId);
@@ -293,7 +293,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             private void sendState(int beatmapId)
             {
                 sentState = true;
-                ((ISpectatorClient)this).UserBeganPlaying((int)StreamingUser.Id, new SpectatorState
+                ((ISpectatorClient)this).UserBeganPlaying(StreamingUser.Id, new SpectatorState
                 {
                     BeatmapID = beatmapId,
                     RulesetID = 0,

osu.Game.Tournament/Screens/Editors/TeamEditorScreen.cs

@@ -277,7 +277,7 @@ namespace osu.Game.Tournament.Screens.Editors
                         userId.Value = user.Id.ToString();
                         userId.BindValueChanged(idString =>
                         {
-                            long.TryParse(idString.NewValue, out var parsed);
+                            int.TryParse(idString.NewValue, out var parsed);
 
                             user.Id = parsed;
 

osu.Game/Beatmaps/BeatmapDifficultyCache.cs

@@ -2,7 +2,6 @@
 // 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;
@@ -11,25 +10,25 @@ 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.Logging;
 using osu.Framework.Threading;
 using osu.Framework.Utils;
+using osu.Game.Database;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Beatmaps
 {
-    public class BeatmapDifficultyManager : CompositeDrawable
+    /// <summary>
+    /// A component which performs and acts as a central cache for difficulty calculations of beatmap/ruleset/mod combinations.
+    /// Currently not persisted between game sessions.
+    /// </summary>
+    public class BeatmapDifficultyCache : MemoryCachingComponent<BeatmapDifficultyCache.DifficultyCacheLookup, StarDifficulty>
     {
         // 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));
+        private readonly ThreadedTaskScheduler updateScheduler = new ThreadedTaskScheduler(1, nameof(BeatmapDifficultyCache));
-
-        // 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>();
@@ -239,7 +238,7 @@ namespace osu.Game.Beatmaps
                 var calculator = ruleset.CreateDifficultyCalculator(beatmapManager.GetWorkingBeatmap(beatmapInfo));
                 var attributes = calculator.Calculate(key.Mods);
 
-                return difficultyCache[key] = new StarDifficulty(attributes);
+                return Cache[key] = new StarDifficulty(attributes);
             }
             catch (BeatmapInvalidForRulesetException e)
             {
@@ -250,7 +249,7 @@ namespace osu.Game.Beatmaps
                 if (rulesetInfo.Equals(beatmapInfo.Ruleset))
                 {
                     Logger.Error(e, $"Failed to convert {beatmapInfo.OnlineBeatmapID} to the beatmap's default ruleset ({beatmapInfo.Ruleset}).");
-                    return difficultyCache[key] = new StarDifficulty();
+                    return Cache[key] = new StarDifficulty();
                 }
 
                 // Check the cache first because this is now a different ruleset than the one previously guarded against.
@@ -261,7 +260,7 @@ namespace osu.Game.Beatmaps
             }
             catch
             {
-                return difficultyCache[key] = new StarDifficulty();
+                return Cache[key] = new StarDifficulty();
             }
         }
 
@@ -290,7 +289,7 @@ namespace osu.Game.Beatmaps
             }
 
             key = new DifficultyCacheLookup(beatmapInfo.ID, rulesetInfo.ID.Value, mods);
-            return difficultyCache.TryGetValue(key, out existingDifficulty);
+            return Cache.TryGetValue(key, out existingDifficulty);
         }
 
         protected override void Dispose(bool isDisposing)
@@ -344,49 +343,4 @@ namespace osu.Game.Beatmaps
             }
         }
     }
-
-    public readonly struct StarDifficulty
-    {
-        /// <summary>
-        /// The star difficulty rating for the given beatmap.
-        /// </summary>
-        public readonly double Stars;
-
-        /// <summary>
-        /// The maximum combo achievable on the given beatmap.
-        /// </summary>
-        public readonly int MaxCombo;
-
-        /// <summary>
-        /// The difficulty attributes computed for the given beatmap.
-        /// Might not be available if the star difficulty is associated with a beatmap that's not locally available.
-        /// </summary>
-        [CanBeNull]
-        public readonly DifficultyAttributes Attributes;
-
-        /// <summary>
-        /// Creates a <see cref="StarDifficulty"/> structure based on <see cref="DifficultyAttributes"/> computed
-        /// by a <see cref="DifficultyCalculator"/>.
-        /// </summary>
-        public StarDifficulty([NotNull] DifficultyAttributes attributes)
-        {
-            Stars = attributes.StarRating;
-            MaxCombo = attributes.MaxCombo;
-            Attributes = attributes;
-            // Todo: Add more members (BeatmapInfo.DifficultyRating? Attributes? Etc...)
-        }
-
-        /// <summary>
-        /// Creates a <see cref="StarDifficulty"/> structure with a pre-populated star difficulty and max combo
-        /// in scenarios where computing <see cref="DifficultyAttributes"/> is not feasible (i.e. when working with online sources).
-        /// </summary>
-        public StarDifficulty(double starDifficulty, int maxCombo)
-        {
-            Stars = starDifficulty;
-            MaxCombo = maxCombo;
-            Attributes = null;
-        }
-
-        public DifficultyRating DifficultyRating => BeatmapDifficultyManager.GetDifficultyRating(Stars);
-    }
 }

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -136,7 +136,7 @@ namespace osu.Game.Beatmaps
         public List<ScoreInfo> Scores { get; set; }
 
         [JsonIgnore]
-        public DifficultyRating DifficultyRating => BeatmapDifficultyManager.GetDifficultyRating(StarDifficulty);
+        public DifficultyRating DifficultyRating => BeatmapDifficultyCache.GetDifficultyRating(StarDifficulty);
 
         public string[] SearchableTerms => new[]
         {

osu.Game/Beatmaps/Drawables/DifficultyIcon.cs

@@ -142,7 +142,7 @@ namespace osu.Game.Beatmaps.Drawables
             private CancellationTokenSource difficultyCancellation;
 
             [Resolved]
-            private BeatmapDifficultyManager difficultyManager { get; set; }
+            private BeatmapDifficultyCache difficultyCache { get; set; }
 
             public DifficultyRetriever(BeatmapInfo beatmap, RulesetInfo ruleset, IReadOnlyList<Mod> mods)
             {
@@ -158,8 +158,8 @@ namespace osu.Game.Beatmaps.Drawables
             {
                 difficultyCancellation = new CancellationTokenSource();
                 localStarDifficulty = ruleset != null
-                    ? difficultyManager.GetBindableDifficulty(beatmap, ruleset, mods, difficultyCancellation.Token)
+                    ? difficultyCache.GetBindableDifficulty(beatmap, ruleset, mods, difficultyCancellation.Token)
-                    : difficultyManager.GetBindableDifficulty(beatmap, difficultyCancellation.Token);
+                    : difficultyCache.GetBindableDifficulty(beatmap, difficultyCancellation.Token);
                 localStarDifficulty.BindValueChanged(difficulty => StarDifficulty.Value = difficulty.NewValue);
             }
 

osu.Game/Beatmaps/StarDifficulty.cs

@@ -0,0 +1,53 @@
+// 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 JetBrains.Annotations;
+using osu.Game.Rulesets.Difficulty;
+
+namespace osu.Game.Beatmaps
+{
+    public readonly struct StarDifficulty
+    {
+        /// <summary>
+        /// The star difficulty rating for the given beatmap.
+        /// </summary>
+        public readonly double Stars;
+
+        /// <summary>
+        /// The maximum combo achievable on the given beatmap.
+        /// </summary>
+        public readonly int MaxCombo;
+
+        /// <summary>
+        /// The difficulty attributes computed for the given beatmap.
+        /// Might not be available if the star difficulty is associated with a beatmap that's not locally available.
+        /// </summary>
+        [CanBeNull]
+        public readonly DifficultyAttributes Attributes;
+
+        /// <summary>
+        /// Creates a <see cref="StarDifficulty"/> structure based on <see cref="DifficultyAttributes"/> computed
+        /// by a <see cref="DifficultyCalculator"/>.
+        /// </summary>
+        public StarDifficulty([NotNull] DifficultyAttributes attributes)
+        {
+            Stars = attributes.StarRating;
+            MaxCombo = attributes.MaxCombo;
+            Attributes = attributes;
+            // Todo: Add more members (BeatmapInfo.DifficultyRating? Attributes? Etc...)
+        }
+
+        /// <summary>
+        /// Creates a <see cref="StarDifficulty"/> structure with a pre-populated star difficulty and max combo
+        /// in scenarios where computing <see cref="DifficultyAttributes"/> is not feasible (i.e. when working with online sources).
+        /// </summary>
+        public StarDifficulty(double starDifficulty, int maxCombo)
+        {
+            Stars = starDifficulty;
+            MaxCombo = maxCombo;
+            Attributes = null;
+        }
+
+        public DifficultyRating DifficultyRating => BeatmapDifficultyCache.GetDifficultyRating(Stars);
+    }
+}

osu.Game/Database/MemoryCachingComponent.cs

@@ -0,0 +1,17 @@
+// 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.Concurrent;
+using osu.Framework.Graphics;
+
+namespace osu.Game.Database
+{
+    /// <summary>
+    /// A component which performs lookups (or calculations) and caches the results.
+    /// Currently not persisted between game sessions.
+    /// </summary>
+    public abstract class MemoryCachingComponent<TLookup, TValue> : Component
+    {
+        protected readonly ConcurrentDictionary<TLookup, TValue> Cache = new ConcurrentDictionary<TLookup, TValue>();
+    }
+}

osu.Game/Online/API/Requests/Responses/APIBeatmapSet.cs

@@ -61,7 +61,7 @@ namespace osu.Game.Online.API.Requests.Responses
         private int[] ratings { get; set; }
 
         [JsonProperty(@"user_id")]
-        private long creatorId
+        private int creatorId
         {
             set => Author.Id = value;
         }

osu.Game/Online/API/Requests/Responses/APIChangelogUser.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Online.API.Requests.Responses
         public string OsuUsername { get; set; }
 
         [JsonProperty("user_id")]
-        public long? UserId { get; set; }
+        public int? UserId { get; set; }
 
         [JsonProperty("user_url")]
         public string UserUrl { get; set; }

osu.Game/Online/Chat/Channel.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Online.Chat
         public readonly ObservableCollection<User> Users = new ObservableCollection<User>();
 
         [JsonProperty(@"users")]
-        private long[] userIds
+        private int[] userIds
         {
             set
             {

osu.Game/OsuGame.cs

@@ -278,7 +278,7 @@ namespace osu.Game
                     break;
 
                 case LinkAction.OpenUserProfile:
-                    if (long.TryParse(link.Argument, out long userId))
+                    if (int.TryParse(link.Argument, out int userId))
                         ShowUser(userId);
                     break;
 
@@ -321,7 +321,7 @@ namespace osu.Game
         /// Show a user's profile as an overlay.
         /// </summary>
         /// <param name="userId">The user to display.</param>
-        public void ShowUser(long userId) => waitForReady(() => userProfile, _ => userProfile.ShowUser(userId));
+        public void ShowUser(int userId) => waitForReady(() => userProfile, _ => userProfile.ShowUser(userId));
 
         /// <summary>
         /// Show a beatmap's set as an overlay, displaying the given beatmap.

osu.Game/OsuGameBase.cs

@@ -59,7 +59,7 @@ namespace osu.Game
 
         protected ScoreManager ScoreManager;
 
-        protected BeatmapDifficultyManager DifficultyManager;
+        protected BeatmapDifficultyCache DifficultyCache;
 
         protected SkinManager SkinManager;
 
@@ -202,7 +202,7 @@ namespace osu.Game
             dependencies.Cache(FileStore = new FileStore(contextFactory, Storage));
 
             // ordering is important here to ensure foreign keys rules are not broken in ModelStore.Cleanup()
-            dependencies.Cache(ScoreManager = new ScoreManager(RulesetStore, () => BeatmapManager, Storage, API, contextFactory, Host, () => DifficultyManager, LocalConfig));
+            dependencies.Cache(ScoreManager = new ScoreManager(RulesetStore, () => BeatmapManager, Storage, API, contextFactory, Host, () => DifficultyCache, LocalConfig));
             dependencies.Cache(BeatmapManager = new BeatmapManager(Storage, contextFactory, RulesetStore, API, Audio, Host, defaultBeatmap, true));
 
             // this should likely be moved to ArchiveModelManager when another case appers where it is necessary
@@ -226,10 +226,10 @@ namespace osu.Game
                     ScoreManager.Undelete(getBeatmapScores(item), true);
             });
 
-            dependencies.Cache(DifficultyManager = new BeatmapDifficultyManager());
+            dependencies.Cache(DifficultyCache = new BeatmapDifficultyCache());
-            AddInternal(DifficultyManager);
+            AddInternal(DifficultyCache);
 
-            var scorePerformanceManager = new ScorePerformanceManager();
+            var scorePerformanceManager = new ScorePerformanceCache();
             dependencies.Cache(scorePerformanceManager);
             AddInternal(scorePerformanceManager);
 

osu.Game/Overlays/Dashboard/CurrentlyPlayingDisplay.cs

@@ -59,7 +59,7 @@ namespace osu.Game.Overlays.Dashboard
                             var request = new GetUserRequest(u);
                             request.Success += user => Schedule(() =>
                             {
-                                if (playingUsers.Contains((int)user.Id))
+                                if (playingUsers.Contains(user.Id))
                                     userFlow.Add(createUserPanel(user));
                             });
                             api.Queue(request);

osu.Game/Overlays/UserProfileOverlay.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Overlays
         {
         }
 
-        public void ShowUser(long userId) => ShowUser(new User { Id = userId });
+        public void ShowUser(int userId) => ShowUser(new User { Id = userId });
 
         public void ShowUser(User user, bool fetchOnline = true)
         {

osu.Game/Rulesets/Mods/ModHidden.cs

@@ -1,19 +1,16 @@
 // 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.Configuration;
+using System;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
-using System.Collections.Generic;
-using System.Linq;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 
 namespace osu.Game.Rulesets.Mods
 {
-    public abstract class ModHidden : Mod, IReadFromConfig, IApplicableToDrawableHitObjects, IApplicableToScoreProcessor
+    public abstract class ModHidden : ModWithVisibilityAdjustment, IApplicableToScoreProcessor
     {
         public override string Name => "Hidden";
         public override string Acronym => "HD";
@@ -21,37 +18,14 @@ namespace osu.Game.Rulesets.Mods
         public override ModType Type => ModType.DifficultyIncrease;
         public override bool Ranked => true;
 
-        protected Bindable<bool> IncreaseFirstObjectVisibility = new Bindable<bool>();
-
         /// <summary>
         /// Check whether the provided hitobject should be considered the "first" hideable object.
         /// Can be used to skip spinners, for instance.
         /// </summary>
         /// <param name="hitObject">The hitobject to check.</param>
+        [Obsolete("Use IsFirstAdjustableObject() instead.")] // Can be removed 20210506
         protected virtual bool IsFirstHideableObject(DrawableHitObject hitObject) => true;
 
-        public void ReadFromConfig(OsuConfigManager config)
-        {
-            IncreaseFirstObjectVisibility = config.GetBindable<bool>(OsuSetting.IncreaseFirstObjectVisibility);
-        }
-
-        public virtual void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
-        {
-            if (IncreaseFirstObjectVisibility.Value)
-            {
-                drawables = drawables.SkipWhile(h => !IsFirstHideableObject(h));
-
-                var firstObject = drawables.FirstOrDefault();
-                if (firstObject != null)
-                    firstObject.ApplyCustomUpdateState += ApplyFirstObjectIncreaseVisibilityState;
-
-                drawables = drawables.Skip(1);
-            }
-
-            foreach (var dho in drawables)
-                dho.ApplyCustomUpdateState += ApplyHiddenState;
-        }
-
         public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
         {
             // Default value of ScoreProcessor's Rank in Hidden Mod should be SS+
@@ -73,11 +47,26 @@ namespace osu.Game.Rulesets.Mods
             }
         }
 
+        protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
+        {
+#pragma warning disable 618
+            ApplyFirstObjectIncreaseVisibilityState(hitObject, state);
+#pragma warning restore 618
+        }
+
+        protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
+        {
+#pragma warning disable 618
+            ApplyHiddenState(hitObject, state);
+#pragma warning restore 618
+        }
+
         /// <summary>
         /// Apply a special visibility state to the first object in a beatmap, if the user chooses to turn on the "increase first object visibility" setting.
         /// </summary>
         /// <param name="hitObject">The hit object to apply the state change to.</param>
         /// <param name="state">The state of the hit object.</param>
+        [Obsolete("Use ApplyIncreasedVisibilityState() instead.")] // Can be removed 20210506
         protected virtual void ApplyFirstObjectIncreaseVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
         }
@@ -87,6 +76,7 @@ namespace osu.Game.Rulesets.Mods
         /// </summary>
         /// <param name="hitObject">The hit object to apply the state change to.</param>
         /// <param name="state">The state of the hit object.</param>
+        [Obsolete("Use ApplyNormalVisibilityState() instead.")] // Can be removed 20210506
         protected virtual void ApplyHiddenState(DrawableHitObject hitObject, ArmedState state)
         {
         }

osu.Game/Rulesets/Mods/ModWithVisibilityAdjustment.cs

@@ -0,0 +1,114 @@
+// 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.Bindables;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mods
+{
+    /// <summary>
+    /// A <see cref="Mod"/> which applies visibility adjustments to <see cref="DrawableHitObject"/>s
+    /// with an optional increased visibility adjustment depending on the user's "increase first object visibility" setting.
+    /// </summary>
+    public abstract class ModWithVisibilityAdjustment : Mod, IReadFromConfig, IApplicableToBeatmap, IApplicableToDrawableHitObjects
+    {
+        /// <summary>
+        /// The first adjustable object.
+        /// </summary>
+        protected HitObject FirstObject { get; private set; }
+
+        /// <summary>
+        /// Whether the visibility of <see cref="FirstObject"/> should be increased.
+        /// </summary>
+        protected readonly Bindable<bool> IncreaseFirstObjectVisibility = new Bindable<bool>();
+
+        /// <summary>
+        /// Check whether the provided hitobject should be considered the "first" adjustable object.
+        /// Can be used to skip spinners, for instance.
+        /// </summary>
+        /// <param name="hitObject">The hitobject to check.</param>
+        protected virtual bool IsFirstAdjustableObject(HitObject hitObject) => true;
+
+        /// <summary>
+        /// Apply a special increased-visibility state to the first adjustable object.
+        /// Only applicable if the user chooses to turn on the "increase first object visibility" setting.
+        /// </summary>
+        /// <param name="hitObject">The hit object to apply the state change to.</param>
+        /// <param name="state">The state of the hitobject.</param>
+        protected abstract void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state);
+
+        /// <summary>
+        /// Apply a normal visibility state adjustment to an object.
+        /// </summary>
+        /// <param name="hitObject">The hit object to apply the state change to.</param>
+        /// <param name="state">The state of the hitobject.</param>
+        protected abstract void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state);
+
+        public virtual void ReadFromConfig(OsuConfigManager config)
+        {
+            config.BindWith(OsuSetting.IncreaseFirstObjectVisibility, IncreaseFirstObjectVisibility);
+        }
+
+        public virtual void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            FirstObject = getFirstAdjustableObjectRecursive(beatmap.HitObjects);
+
+            HitObject getFirstAdjustableObjectRecursive(IReadOnlyList<HitObject> hitObjects)
+            {
+                foreach (var h in hitObjects)
+                {
+                    if (IsFirstAdjustableObject(h))
+                        return h;
+
+                    var nestedResult = getFirstAdjustableObjectRecursive(h.NestedHitObjects);
+                    if (nestedResult != null)
+                        return nestedResult;
+                }
+
+                return null;
+            }
+        }
+
+        public virtual void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        {
+            foreach (var dho in drawables)
+            {
+                dho.ApplyCustomUpdateState += (o, state) =>
+                {
+                    // Increased visibility is applied to the entire first object, including all of its nested hitobjects.
+                    if (IncreaseFirstObjectVisibility.Value && isObjectEqualToOrNestedIn(o.HitObject, FirstObject))
+                        ApplyIncreasedVisibilityState(o, state);
+                    else
+                        ApplyNormalVisibilityState(o, state);
+                };
+            }
+        }
+
+        /// <summary>
+        /// Checks whether a given object is nested within a target.
+        /// </summary>
+        /// <param name="toCheck">The <see cref="HitObject"/> to check.</param>
+        /// <param name="target">The <see cref="HitObject"/> which may be equal to or contain <paramref name="toCheck"/> as a nested object.</param>
+        /// <returns>Whether <paramref name="toCheck"/> is equal to or nested within <paramref name="target"/>.</returns>
+        private bool isObjectEqualToOrNestedIn(HitObject toCheck, HitObject target)
+        {
+            if (target == null)
+                return false;
+
+            if (toCheck == target)
+                return true;
+
+            foreach (var h in target.NestedHitObjects)
+            {
+                if (isObjectEqualToOrNestedIn(toCheck, h))
+                    return true;
+            }
+
+            return false;
+        }
+    }
+}

osu.Game/Scoring/ScoreInfo.cs

@@ -123,7 +123,7 @@ namespace osu.Game.Scoring
 
         [JsonIgnore]
         [Column("UserID")]
-        public long? UserID
+        public int? UserID
         {
             get => User?.Id ?? 1;
             set

osu.Game/Scoring/ScoreManager.cs

@@ -37,13 +37,13 @@ namespace osu.Game.Scoring
         private readonly Func<BeatmapManager> beatmaps;
 
         [CanBeNull]
-        private readonly Func<BeatmapDifficultyManager> difficulties;
+        private readonly Func<BeatmapDifficultyCache> difficulties;
 
         [CanBeNull]
         private readonly OsuConfigManager configManager;
 
         public ScoreManager(RulesetStore rulesets, Func<BeatmapManager> beatmaps, Storage storage, IAPIProvider api, IDatabaseContextFactory contextFactory, IIpcHost importHost = null,
-                            Func<BeatmapDifficultyManager> difficulties = null, OsuConfigManager configManager = null)
+                            Func<BeatmapDifficultyCache> difficulties = null, OsuConfigManager configManager = null)
             : base(storage, contextFactory, api, new ScoreStore(contextFactory, storage), importHost)
         {
             this.rulesets = rulesets;
@@ -121,14 +121,14 @@ namespace osu.Game.Scoring
             public readonly Bindable<ScoringMode> ScoringMode = new Bindable<ScoringMode>();
 
             private readonly ScoreInfo score;
-            private readonly Func<BeatmapDifficultyManager> difficulties;
+            private readonly Func<BeatmapDifficultyCache> difficulties;
 
             /// <summary>
             /// Creates a new <see cref="TotalScoreBindable"/>.
             /// </summary>
             /// <param name="score">The <see cref="ScoreInfo"/> to provide the total score of.</param>
-            /// <param name="difficulties">A function to retrieve the <see cref="BeatmapDifficultyManager"/>.</param>
+            /// <param name="difficulties">A function to retrieve the <see cref="BeatmapDifficultyCache"/>.</param>
-            public TotalScoreBindable(ScoreInfo score, Func<BeatmapDifficultyManager> difficulties)
+            public TotalScoreBindable(ScoreInfo score, Func<BeatmapDifficultyCache> difficulties)
             {
                 this.score = score;
                 this.difficulties = difficulties;

osu.Game/Scoring/ScorePerformanceCache.cs

@@ -2,27 +2,23 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Concurrent;
 using System.Threading;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
 
 namespace osu.Game.Scoring
 {
     /// <summary>
-    /// A global component which calculates and caches results of performance calculations for locally databased scores.
+    /// A component which performs and acts as a central cache for performance calculations of locally databased scores.
+    /// Currently not persisted between game sessions.
     /// </summary>
-    public class ScorePerformanceManager : Component
+    public class ScorePerformanceCache : MemoryCachingComponent<ScorePerformanceCache.PerformanceCacheLookup, double>
     {
-        // this cache will grow indefinitely per session and should be considered temporary.
-        // this whole component should likely be replaced with database persistence.
-        private readonly ConcurrentDictionary<PerformanceCacheLookup, double> performanceCache = new ConcurrentDictionary<PerformanceCacheLookup, double>();
-
         [Resolved]
-        private BeatmapDifficultyManager difficultyManager { get; set; }
+        private BeatmapDifficultyCache difficultyCache { get; set; }
 
         /// <summary>
         /// Calculates performance for the given <see cref="ScoreInfo"/>.
@@ -33,7 +29,7 @@ namespace osu.Game.Scoring
         {
             var lookupKey = new PerformanceCacheLookup(score);
 
-            if (performanceCache.TryGetValue(lookupKey, out double performance))
+            if (Cache.TryGetValue(lookupKey, out double performance))
                 return Task.FromResult((double?)performance);
 
             return computePerformanceAsync(score, lookupKey, token);
@@ -41,7 +37,7 @@ namespace osu.Game.Scoring
 
         private async Task<double?> computePerformanceAsync(ScoreInfo score, PerformanceCacheLookup lookupKey, CancellationToken token = default)
         {
-            var attributes = await difficultyManager.GetDifficultyAsync(score.Beatmap, score.Ruleset, score.Mods, token);
+            var attributes = await difficultyCache.GetDifficultyAsync(score.Beatmap, score.Ruleset, score.Mods, token);
 
             // Performance calculation requires the beatmap and ruleset to be locally available. If not, return a default value.
             if (attributes.Attributes == null)
@@ -53,7 +49,7 @@ namespace osu.Game.Scoring
             var total = calculator?.Calculate();
 
             if (total.HasValue)
-                performanceCache[lookupKey] = total.Value;
+                Cache[lookupKey] = total.Value;
 
             return total;
         }

osu.Game/Screens/Play/Spectator.cs

@@ -182,7 +182,7 @@ namespace osu.Game.Screens.Play
             spectatorStreaming.OnUserFinishedPlaying += userFinishedPlaying;
             spectatorStreaming.OnNewFrames += userSentFrames;
 
-            spectatorStreaming.WatchUser((int)targetUser.Id);
+            spectatorStreaming.WatchUser(targetUser.Id);
 
             managerUpdated = beatmaps.ItemUpdated.GetBoundCopy();
             managerUpdated.BindValueChanged(beatmapUpdated);
@@ -353,7 +353,7 @@ namespace osu.Game.Screens.Play
                 spectatorStreaming.OnUserFinishedPlaying -= userFinishedPlaying;
                 spectatorStreaming.OnNewFrames -= userSentFrames;
 
-                spectatorStreaming.StopWatchingUser((int)targetUser.Id);
+                spectatorStreaming.StopWatchingUser(targetUser.Id);
             }
 
             managerUpdated?.UnbindAll();

osu.Game/Screens/Ranking/Expanded/ExpandedPanelMiddleContent.cs

@@ -56,7 +56,7 @@ namespace osu.Game.Screens.Ranking.Expanded
         }
 
         [BackgroundDependencyLoader]
-        private void load(BeatmapDifficultyManager beatmapDifficultyManager)
+        private void load(BeatmapDifficultyCache beatmapDifficultyCache)
         {
             var beatmap = score.Beatmap;
             var metadata = beatmap.BeatmapSet?.Metadata ?? beatmap.Metadata;
@@ -143,7 +143,7 @@ namespace osu.Game.Screens.Ranking.Expanded
                                     Spacing = new Vector2(5, 0),
                                     Children = new Drawable[]
                                     {
-                                        new StarRatingDisplay(beatmapDifficultyManager.GetDifficulty(beatmap, score.Ruleset, score.Mods))
+                                        new StarRatingDisplay(beatmapDifficultyCache.GetDifficulty(beatmap, score.Ruleset, score.Mods))
                                         {
                                             Anchor = Anchor.CentreLeft,
                                             Origin = Anchor.CentreLeft

osu.Game/Screens/Ranking/Expanded/StarRatingDisplay.cs

@@ -34,7 +34,7 @@ namespace osu.Game.Screens.Ranking.Expanded
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, BeatmapDifficultyManager difficultyManager)
+        private void load(OsuColour colours, BeatmapDifficultyCache difficultyCache)
         {
             AutoSizeAxes = Axes.Both;
 

osu.Game/Screens/Ranking/Expanded/Statistics/PerformanceStatistic.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Screens.Ranking.Expanded.Statistics
         }
 
         [BackgroundDependencyLoader]
-        private void load(ScorePerformanceManager performanceManager)
+        private void load(ScorePerformanceCache performanceCache)
         {
             if (score.PP.HasValue)
             {
@@ -36,7 +36,7 @@ namespace osu.Game.Screens.Ranking.Expanded.Statistics
             }
             else
             {
-                performanceManager.CalculatePerformanceAsync(score, cancellationTokenSource.Token)
+                performanceCache.CalculatePerformanceAsync(score, cancellationTokenSource.Token)
                                 .ContinueWith(t => Schedule(() => setPerformanceValue(t.Result)), cancellationTokenSource.Token);
             }
         }

osu.Game/Screens/Select/BeatmapInfoWedge.cs

@@ -41,7 +41,7 @@ namespace osu.Game.Screens.Select
         private readonly IBindable<RulesetInfo> ruleset = new Bindable<RulesetInfo>();
 
         [Resolved]
-        private BeatmapDifficultyManager difficultyManager { get; set; }
+        private BeatmapDifficultyCache difficultyCache { get; set; }
 
         private IBindable<StarDifficulty> beatmapDifficulty;
 
@@ -100,7 +100,7 @@ namespace osu.Game.Screens.Select
                 cancellationSource = new CancellationTokenSource();
 
                 beatmapDifficulty?.UnbindAll();
-                beatmapDifficulty = difficultyManager.GetBindableDifficulty(beatmap.BeatmapInfo, cancellationSource.Token);
+                beatmapDifficulty = difficultyCache.GetBindableDifficulty(beatmap.BeatmapInfo, cancellationSource.Token);
                 beatmapDifficulty.BindValueChanged(_ => updateDisplay());
 
                 updateDisplay();

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

@@ -55,7 +55,7 @@ namespace osu.Game.Screens.Select.Carousel
         private BeatmapSetOverlay beatmapOverlay { get; set; }
 
         [Resolved]
-        private BeatmapDifficultyManager difficultyManager { get; set; }
+        private BeatmapDifficultyCache difficultyCache { get; set; }
 
         [Resolved(CanBeNull = true)]
         private CollectionManager collectionManager { get; set; }
@@ -216,7 +216,7 @@ namespace osu.Game.Screens.Select.Carousel
             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 = difficultyCache.GetBindableDifficulty(beatmap, (starDifficultyCancellationSource = new CancellationTokenSource()).Token);
                 starDifficultyBindable.BindValueChanged(d => starCounter.Current = (float)d.NewValue.Stars, true);
             }
 

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

@@ -32,7 +32,7 @@ namespace osu.Game.Screens.Select.Details
         private IBindable<RulesetInfo> ruleset { get; set; }
 
         [Resolved]
-        private BeatmapDifficultyManager difficultyManager { get; set; }
+        private BeatmapDifficultyCache difficultyCache { get; set; }
 
         protected readonly StatisticRow FirstValue, HpDrain, Accuracy, ApproachRate;
         private readonly StatisticRow starDifficulty;
@@ -161,8 +161,8 @@ namespace osu.Game.Screens.Select.Details
 
             starDifficultyCancellationSource = new CancellationTokenSource();
 
-            normalStarDifficulty = difficultyManager.GetBindableDifficulty(Beatmap, ruleset.Value, null, starDifficultyCancellationSource.Token);
+            normalStarDifficulty = difficultyCache.GetBindableDifficulty(Beatmap, ruleset.Value, null, starDifficultyCancellationSource.Token);
-            moddedStarDifficulty = difficultyManager.GetBindableDifficulty(Beatmap, ruleset.Value, mods.Value, starDifficultyCancellationSource.Token);
+            moddedStarDifficulty = difficultyCache.GetBindableDifficulty(Beatmap, ruleset.Value, mods.Value, starDifficultyCancellationSource.Token);
 
             normalStarDifficulty.BindValueChanged(_ => updateDisplay());
             moddedStarDifficulty.BindValueChanged(_ => updateDisplay(), true);

osu.Game/Users/User.cs

@@ -12,7 +12,7 @@ namespace osu.Game.Users
     public class User : IEquatable<User>
     {
         [JsonProperty(@"id")]
-        public long Id = 1;
+        public int Id = 1;
 
         [JsonProperty(@"join_date")]
         public DateTimeOffset JoinDate;

osu.Game/osu.Game.csproj

@@ -26,7 +26,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-    <PackageReference Include="ppy.osu.Framework" Version="2020.1029.1" />
+    <PackageReference Include="ppy.osu.Framework" Version="2020.1105.0" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1030.0" />
     <PackageReference Include="Sentry" Version="2.1.6" />
     <PackageReference Include="SharpCompress" Version="0.26.0" />

osu.iOS.props

@@ -70,7 +70,7 @@
     <Reference Include="System.Net.Http" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2020.1029.1" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2020.1105.0" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1030.0" />
   </ItemGroup>
   <!-- See https://github.com/dotnet/runtime/issues/35988 (can be removed after Xamarin uses net5.0 / net6.0) -->
@@ -88,7 +88,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-    <PackageReference Include="ppy.osu.Framework" Version="2020.1029.1" />
+    <PackageReference Include="ppy.osu.Framework" Version="2020.1105.0" />
     <PackageReference Include="SharpCompress" Version="0.26.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />