Merge branch 'master' into multi-queueing-modes

Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/EmptyFreeformDifficultyCalculator.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.EmptyFreeform
 {
     public class EmptyFreeformDifficultyCalculator : DifficultyCalculator
     {
-        public EmptyFreeformDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public EmptyFreeformDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }

Templates/Rulesets/ruleset-empty/osu.Game.Rulesets.EmptyFreeform/EmptyFreeformRuleset.cs

@@ -30,8 +30,8 @@ namespace osu.Game.Rulesets.EmptyFreeform
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) =>
             new EmptyFreeformBeatmapConverter(beatmap, this);
 
-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) =>
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) =>
-            new EmptyFreeformDifficultyCalculator(this, beatmap);
+            new EmptyFreeformDifficultyCalculator(RulesetInfo, beatmap);
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {

Templates/Rulesets/ruleset-example/osu.Game.Rulesets.Pippidon/PippidonDifficultyCalculator.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Pippidon
 {
     public class PippidonDifficultyCalculator : DifficultyCalculator
     {
-        public PippidonDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public PippidonDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }

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

@@ -26,8 +26,8 @@ namespace osu.Game.Rulesets.Pippidon
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) =>
             new PippidonBeatmapConverter(beatmap, this);
 
-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) =>
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) =>
-            new PippidonDifficultyCalculator(this, beatmap);
+            new PippidonDifficultyCalculator(RulesetInfo, beatmap);
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {

Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/EmptyScrollingDifficultyCalculator.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.EmptyScrolling
 {
     public class EmptyScrollingDifficultyCalculator : DifficultyCalculator
     {
-        public EmptyScrollingDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public EmptyScrollingDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }

Templates/Rulesets/ruleset-scrolling-empty/osu.Game.Rulesets.EmptyScrolling/EmptyScrollingRuleset.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.EmptyScrolling
 
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new EmptyScrollingBeatmapConverter(beatmap, this);
 
-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new EmptyScrollingDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new EmptyScrollingDifficultyCalculator(RulesetInfo, beatmap);
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {

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

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Pippidon
 {
     public class PippidonDifficultyCalculator : DifficultyCalculator
     {
-        public PippidonDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public PippidonDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Pippidon
 
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new PippidonBeatmapConverter(beatmap, this);
 
-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new PippidonDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new PippidonDifficultyCalculator(RulesetInfo, beatmap);
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {

osu.Desktop/OsuGameDesktop.cs

@@ -93,6 +93,11 @@ namespace osu.Desktop
 
         protected override UpdateManager CreateUpdateManager()
         {
+            string packageManaged = Environment.GetEnvironmentVariable("OSU_EXTERNAL_UPDATE_PROVIDER");
+
+            if (!string.IsNullOrEmpty(packageManaged))
+                return new NoActionUpdateManager();
+
             switch (RuntimeInfo.OS)
             {
                 case RuntimeInfo.Platform.Windows:

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -183,6 +183,19 @@ namespace osu.Desktop.Updater
                     }
                 });
             }
+
+            public override void Close()
+            {
+                // cancelling updates is not currently supported by the underlying updater.
+                // only allow dismissing for now.
+
+                switch (State)
+                {
+                    case ProgressNotificationState.Cancelled:
+                        base.Close();
+                        break;
+                }
+            }
         }
 
         private class SquirrelLogger : Splat.ILogger, IDisposable

osu.Game.Rulesets.Catch.Tests/CatchDifficultyCalculatorTest.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         public void TestClockRateAdjusted(double expected, string name)
             => Test(expected, name, new CatchModDoubleTime());
 
-        protected override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(new CatchRuleset(), beatmap);
+        protected override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new CatchDifficultyCalculator(new CatchRuleset().RulesetInfo, beatmap);
 
         protected override Ruleset CreateRuleset() => new CatchRuleset();
     }

osu.Game.Rulesets.Catch.Tests/TestSceneDrawableHitObjects.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             var controlPointInfo = new ControlPointInfo();
             controlPointInfo.Add(0, new TimingControlPoint());
 
-            WorkingBeatmap beatmap = CreateWorkingBeatmap(new Beatmap
+            IWorkingBeatmap beatmap = CreateWorkingBeatmap(new Beatmap
             {
                 HitObjects = new List<HitObject> { new Fruit() },
                 BeatmapInfo = new BeatmapInfo

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -178,7 +178,7 @@ namespace osu.Game.Rulesets.Catch
             return base.GetDisplayNameForHitResult(result);
         }
 
-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new CatchDifficultyCalculator(RulesetInfo, beatmap);
 
         public override ISkin CreateLegacySkinProvider(ISkin skin, IBeatmap beatmap) => new CatchLegacySkinTransformer(skin);
 

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

@@ -1,12 +1,35 @@
 // 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 Newtonsoft.Json;
 using osu.Game.Rulesets.Difficulty;
 
 namespace osu.Game.Rulesets.Catch.Difficulty
 {
     public class CatchDifficultyAttributes : DifficultyAttributes
     {
+        [JsonProperty("approach_rate")]
         public double ApproachRate { get; set; }
+
+        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
+        {
+            foreach (var v in base.ToDatabaseAttributes())
+                yield return v;
+
+            // Todo: osu!catch should not output star rating in the 'aim' attribute.
+            yield return (ATTRIB_ID_AIM, StarRating);
+            yield return (ATTRIB_ID_APPROACH_RATE, ApproachRate);
+            yield return (ATTRIB_ID_MAX_COMBO, MaxCombo);
+        }
+
+        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values)
+        {
+            base.FromDatabaseAttributes(values);
+
+            StarRating = values[ATTRIB_ID_AIM];
+            ApproachRate = values[ATTRIB_ID_APPROACH_RATE];
+            MaxCombo = (int)values[ATTRIB_ID_MAX_COMBO];
+        }
     }
 }

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

@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         private float halfCatcherWidth;
 
-        public CatchDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public CatchDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }

osu.Game.Rulesets.Mania.Tests/ManiaDifficultyCalculatorTest.cs

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         public void TestClockRateAdjusted(double expected, string name)
             => Test(expected, name, new ManiaModDoubleTime());
 
-        protected override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new ManiaDifficultyCalculator(new ManiaRuleset(), beatmap);
+        protected override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new ManiaDifficultyCalculator(new ManiaRuleset().RulesetInfo, beatmap);
 
         protected override Ruleset CreateRuleset() => new ManiaRuleset();
     }

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyAttributes.cs

@@ -1,13 +1,38 @@
 // 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 Newtonsoft.Json;
 using osu.Game.Rulesets.Difficulty;
 
 namespace osu.Game.Rulesets.Mania.Difficulty
 {
     public class ManiaDifficultyAttributes : DifficultyAttributes
     {
+        [JsonProperty("great_hit_window")]
         public double GreatHitWindow { get; set; }
+
+        [JsonProperty("score_multiplier")]
         public double ScoreMultiplier { get; set; }
+
+        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
+        {
+            foreach (var v in base.ToDatabaseAttributes())
+                yield return v;
+
+            // Todo: osu!mania doesn't output MaxCombo attribute for some reason.
+            yield return (ATTRIB_ID_STRAIN, StarRating);
+            yield return (ATTRIB_ID_GREAT_HIT_WINDOW, GreatHitWindow);
+            yield return (ATTRIB_ID_SCORE_MULTIPLIER, ScoreMultiplier);
+        }
+
+        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values)
+        {
+            base.FromDatabaseAttributes(values);
+
+            StarRating = values[ATTRIB_ID_STRAIN];
+            GreatHitWindow = values[ATTRIB_ID_GREAT_HIT_WINDOW];
+            ScoreMultiplier = values[ATTRIB_ID_SCORE_MULTIPLIER];
+        }
     }
 }

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Extensions;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
@@ -28,11 +29,11 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         private readonly bool isForCurrentRuleset;
         private readonly double originalOverallDifficulty;
 
-        public ManiaDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public ManiaDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
-            isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.Equals(ruleset.RulesetInfo);
+            isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.MatchesOnlineID(ruleset);
-            originalOverallDifficulty = beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty;
+            originalOverallDifficulty = beatmap.BeatmapInfo.Difficulty.OverallDifficulty;
         }
 
         protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -272,7 +272,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetMania };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new ManiaDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new ManiaDifficultyCalculator(RulesetInfo, beatmap);
 
         public int LegacyID => 3;
 

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

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         public void TestClockRateAdjusted(double expected, string name)
             => Test(expected, name, new OsuModDoubleTime());
 
-        protected override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new OsuDifficultyCalculator(new OsuRuleset(), beatmap);
+        protected override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new OsuDifficultyCalculator(new OsuRuleset().RulesetInfo, beatmap);
 
         protected override Ruleset CreateRuleset() => new OsuRuleset();
     }

osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs

@@ -1,21 +1,77 @@
 // 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 JetBrains.Annotations;
+using Newtonsoft.Json;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Osu.Difficulty
 {
     public class OsuDifficultyAttributes : DifficultyAttributes
     {
+        [JsonProperty("aim_strain")]
         public double AimStrain { get; set; }
+
+        [JsonProperty("speed_strain")]
         public double SpeedStrain { get; set; }
+
+        [JsonProperty("flashlight_rating")]
         public double FlashlightRating { get; set; }
+
+        [JsonProperty("slider_factor")]
         public double SliderFactor { get; set; }
+
+        [JsonProperty("approach_rate")]
         public double ApproachRate { get; set; }
+
+        [JsonProperty("overall_difficulty")]
         public double OverallDifficulty { get; set; }
+
         public double DrainRate { get; set; }
+
         public int HitCircleCount { get; set; }
+
         public int SliderCount { get; set; }
+
         public int SpinnerCount { get; set; }
+
+        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
+        {
+            foreach (var v in base.ToDatabaseAttributes())
+                yield return v;
+
+            yield return (ATTRIB_ID_AIM, AimStrain);
+            yield return (ATTRIB_ID_SPEED, SpeedStrain);
+            yield return (ATTRIB_ID_OVERALL_DIFFICULTY, OverallDifficulty);
+            yield return (ATTRIB_ID_APPROACH_RATE, ApproachRate);
+            yield return (ATTRIB_ID_MAX_COMBO, MaxCombo);
+            yield return (ATTRIB_ID_STRAIN, StarRating);
+
+            if (ShouldSerializeFlashlightRating())
+                yield return (ATTRIB_ID_FLASHLIGHT, FlashlightRating);
+
+            yield return (ATTRIB_ID_SLIDER_FACTOR, SliderFactor);
+        }
+
+        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values)
+        {
+            base.FromDatabaseAttributes(values);
+
+            AimStrain = values[ATTRIB_ID_AIM];
+            SpeedStrain = values[ATTRIB_ID_SPEED];
+            OverallDifficulty = values[ATTRIB_ID_OVERALL_DIFFICULTY];
+            ApproachRate = values[ATTRIB_ID_APPROACH_RATE];
+            MaxCombo = (int)values[ATTRIB_ID_MAX_COMBO];
+            StarRating = values[ATTRIB_ID_STRAIN];
+            FlashlightRating = values.GetValueOrDefault(ATTRIB_ID_FLASHLIGHT);
+            SliderFactor = values[ATTRIB_ID_SLIDER_FACTOR];
+        }
+
+        // Used implicitly by Newtonsoft.Json to not serialize flashlight property in some cases.
+        [UsedImplicitly]
+        public bool ShouldSerializeFlashlightRating() => Mods.Any(m => m is ModFlashlight);
     }
 }

osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs

@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         private const double difficulty_multiplier = 0.0675;
         private double hitWindowGreat;
 
-        public OsuDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public OsuDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -208,7 +208,7 @@ namespace osu.Game.Rulesets.Osu
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetOsu };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new OsuDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new OsuDifficultyCalculator(RulesetInfo, beatmap);
 
         public override PerformanceCalculator CreatePerformanceCalculator(DifficultyAttributes attributes, ScoreInfo score) => new OsuPerformanceCalculator(this, attributes, score);
 

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

@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
             var controlPointInfo = new ControlPointInfo();
             controlPointInfo.Add(0, new TimingControlPoint());
 
-            WorkingBeatmap beatmap = CreateWorkingBeatmap(new Beatmap
+            IWorkingBeatmap beatmap = CreateWorkingBeatmap(new Beatmap
             {
                 HitObjects = new List<HitObject> { new Hit { Type = HitType.Centre } },
                 BeatmapInfo = new BeatmapInfo

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

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
         public void TestClockRateAdjusted(double expected, string name)
             => Test(expected, name, new TaikoModDoubleTime());
 
-        protected override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new TaikoDifficultyCalculator(new TaikoRuleset(), beatmap);
+        protected override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new TaikoDifficultyCalculator(new TaikoRuleset().RulesetInfo, beatmap);
 
         protected override Ruleset CreateRuleset() => new TaikoRuleset();
     }

osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs

@@ -1,16 +1,46 @@
 // 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 Newtonsoft.Json;
 using osu.Game.Rulesets.Difficulty;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty
 {
     public class TaikoDifficultyAttributes : DifficultyAttributes
     {
+        [JsonProperty("stamina_strain")]
         public double StaminaStrain { get; set; }
+
+        [JsonProperty("rhythm_strain")]
         public double RhythmStrain { get; set; }
+
+        [JsonProperty("colour_strain")]
         public double ColourStrain { get; set; }
+
+        [JsonProperty("approach_rate")]
         public double ApproachRate { get; set; }
+
+        [JsonProperty("great_hit_window")]
         public double GreatHitWindow { get; set; }
+
+        public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
+        {
+            foreach (var v in base.ToDatabaseAttributes())
+                yield return v;
+
+            yield return (ATTRIB_ID_MAX_COMBO, MaxCombo);
+            yield return (ATTRIB_ID_STRAIN, StarRating);
+            yield return (ATTRIB_ID_GREAT_HIT_WINDOW, GreatHitWindow);
+        }
+
+        public override void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values)
+        {
+            base.FromDatabaseAttributes(values);
+
+            MaxCombo = (int)values[ATTRIB_ID_MAX_COMBO];
+            StarRating = values[ATTRIB_ID_STRAIN];
+            GreatHitWindow = values[ATTRIB_ID_GREAT_HIT_WINDOW];
+        }
     }
 }

osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs

@@ -24,7 +24,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         private const double colour_skill_multiplier = 0.01;
         private const double stamina_skill_multiplier = 0.02;
 
-        public TaikoDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        public TaikoDifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -168,7 +168,7 @@ namespace osu.Game.Rulesets.Taiko
 
         public override HitObjectComposer CreateHitObjectComposer() => new TaikoHitObjectComposer(this);
 
-        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new TaikoDifficultyCalculator(this, beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new TaikoDifficultyCalculator(RulesetInfo, beatmap);
 
         public override PerformanceCalculator CreatePerformanceCalculator(DifficultyAttributes attributes, ScoreInfo score) => new TaikoPerformanceCalculator(this, attributes, score);
 

osu.Game.Tests/Mods/ModDifficultyAdjustTest.cs

@@ -156,7 +156,7 @@ namespace osu.Game.Tests.Mods
                 throw new System.NotImplementedException();
             }
 
-            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap)
+            public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap)
             {
                 throw new System.NotImplementedException();
             }

osu.Game.Tests/NonVisual/BeatmapSetInfoEqualityTest.cs

@@ -3,6 +3,7 @@
 
 using NUnit.Framework;
 using osu.Game.Beatmaps;
+using osu.Game.Extensions;
 
 namespace osu.Game.Tests.NonVisual
 {
@@ -15,7 +16,8 @@ namespace osu.Game.Tests.NonVisual
             var ourInfo = new BeatmapSetInfo { OnlineID = 123 };
             var otherInfo = new BeatmapSetInfo { OnlineID = 123 };
 
-            Assert.AreEqual(ourInfo, otherInfo);
+            Assert.AreNotEqual(ourInfo, otherInfo);
+            Assert.IsTrue(ourInfo.MatchesOnlineID(otherInfo));
         }
 
         [Test]
@@ -33,7 +35,8 @@ namespace osu.Game.Tests.NonVisual
             var ourInfo = new BeatmapSetInfo { ID = 123, OnlineID = 12 };
             var otherInfo = new BeatmapSetInfo { OnlineID = 12 };
 
-            Assert.AreEqual(ourInfo, otherInfo);
+            Assert.AreNotEqual(ourInfo, otherInfo);
+            Assert.IsTrue(ourInfo.MatchesOnlineID(otherInfo));
         }
 
         [Test]

osu.Game.Tests/Online/TestAPIModJsonSerialization.cs

@@ -128,7 +128,7 @@ namespace osu.Game.Tests.Online
 
             public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => throw new NotImplementedException();
 
-            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => throw new NotImplementedException();
+            public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => throw new NotImplementedException();
 
             public override string Description { get; } = string.Empty;
             public override string ShortName { get; } = string.Empty;

osu.Game.Tests/Online/TestAPIModMessagePackSerialization.cs

@@ -90,7 +90,7 @@ namespace osu.Game.Tests.Online
 
             public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => throw new System.NotImplementedException();
 
-            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => throw new System.NotImplementedException();
+            public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => throw new System.NotImplementedException();
 
             public override string Description { get; } = string.Empty;
             public override string ShortName { get; } = string.Empty;

osu.Game.Tests/Skins/TestSceneBeatmapSkinResources.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Tests.Skins
         [Resolved]
         private BeatmapManager beatmaps { get; set; }
 
-        private WorkingBeatmap beatmap;
+        private IWorkingBeatmap beatmap;
 
         [BackgroundDependencyLoader]
         private void load()

osu.Game.Tests/Testing/TestSceneRulesetDependencies.cs

@@ -79,7 +79,7 @@ namespace osu.Game.Tests.Testing
             public override IEnumerable<Mod> GetModsFor(ModType type) => Array.Empty<Mod>();
             public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => null;
             public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => null;
-            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => null;
+            public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => null;
         }
 
         private class TestRulesetConfigManager : IRulesetConfigManager

osu.Game.Tests/Visual/Editing/TestSceneHitObjectComposer.cs

@@ -81,11 +81,11 @@ namespace osu.Game.Tests.Visual.Editing
 
         public class EditorBeatmapContainer : Container
         {
-            private readonly WorkingBeatmap working;
+            private readonly IWorkingBeatmap working;
 
             public EditorBeatmap EditorBeatmap { get; private set; }
 
-            public EditorBeatmapContainer(WorkingBeatmap working)
+            public EditorBeatmapContainer(IWorkingBeatmap working)
             {
                 this.working = working;
 

osu.Game.Tests/Visual/Editing/TestSceneWaveform.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Tests.Visual.Editing
     [TestFixture]
     public class TestSceneWaveform : OsuTestScene
     {
-        private WorkingBeatmap waveformBeatmap;
+        private IWorkingBeatmap waveformBeatmap;
 
         [BackgroundDependencyLoader]
         private void load(AudioManager audio)

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

@@ -293,7 +293,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new TestBeatmapConverter(beatmap, null);
 
-            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => throw new NotImplementedException();
+            public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => throw new NotImplementedException();
 
             public override string Description { get; } = string.Empty;
 

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

@@ -49,7 +49,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) =>
                 throw new System.NotImplementedException();
 
-            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) =>
+            public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) =>
                 throw new System.NotImplementedException();
 
             public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0)

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

@@ -95,8 +95,9 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private void prepareBeatmap()
         {
-            Beatmap.Value = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+            var workingBeatmap = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
-            Beatmap.Value.BeatmapInfo.EpilepsyWarning = epilepsyWarning;
+            workingBeatmap.BeatmapInfo.EpilepsyWarning = epilepsyWarning;
+            Beatmap.Value = workingBeatmap;
 
             foreach (var mod in SelectedMods.Value.OfType<IApplicableToTrack>())
                 mod.ApplyToTrack(Beatmap.Value.Track);

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

@@ -12,7 +12,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 {
     public class TestScenePlayerReferenceLeaking : TestSceneAllRulesetPlayers
     {
-        private readonly WeakList<WorkingBeatmap> workingWeakReferences = new WeakList<WorkingBeatmap>();
+        private readonly WeakList<IWorkingBeatmap> workingWeakReferences = new WeakList<IWorkingBeatmap>();
 
         private readonly WeakList<Player> playerWeakReferences = new WeakList<Player>();
 

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

@@ -182,7 +182,7 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new TestBeatmapConverter(beatmap, this);
 
-            public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => throw new NotImplementedException();
+            public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => throw new NotImplementedException();
 
             public override string Description { get; } = string.Empty;
 

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

@@ -86,7 +86,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             track.Start();
         }
 
-        private void loadStoryboard(WorkingBeatmap working)
+        private void loadStoryboard(IWorkingBeatmap working)
         {
             if (storyboard != null)
                 storyboardContainer.Remove(storyboard);

osu.Game.Tests/Visual/Menus/TestSceneMusicActionHandling.cs

@@ -31,7 +31,7 @@ namespace osu.Game.Tests.Visual.Menus
         public void TestMusicNavigationActions()
         {
             int importId = 0;
-            Queue<(WorkingBeatmap working, TrackChangeDirection changeDirection)> trackChangeQueue = null;
+            Queue<(IWorkingBeatmap working, TrackChangeDirection changeDirection)> trackChangeQueue = null;
 
             // ensure we have at least two beatmaps available to identify the direction the music controller navigated to.
             AddRepeatStep("import beatmap", () => Game.BeatmapManager.Import(new BeatmapSetInfo
@@ -58,7 +58,7 @@ namespace osu.Game.Tests.Visual.Menus
 
             AddStep("bind to track change", () =>
             {
-                trackChangeQueue = new Queue<(WorkingBeatmap, TrackChangeDirection)>();
+                trackChangeQueue = new Queue<(IWorkingBeatmap, TrackChangeDirection)>();
                 Game.MusicController.TrackChanged += (working, changeDirection) => trackChangeQueue.Enqueue((working, changeDirection));
             });
 

osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs

@@ -67,6 +67,19 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("no item selected", () => playlist.SelectedItem.Value == null);
         }
 
+        [Test]
+        public void TestMarkInvalid()
+        {
+            createPlaylist(true, true);
+
+            AddStep("mark item 0 as invalid", () => playlist.Items[0].MarkInvalid());
+
+            moveToItem(0);
+
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            AddAssert("no item selected", () => playlist.SelectedItem.Value == null);
+        }
+
         [Test]
         public void TestSelectable()
         {

osu.Game.Tests/Visual/Navigation/TestScenePresentBeatmap.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
+using osu.Game.Extensions;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mania;
 using osu.Game.Rulesets.Osu;
@@ -139,7 +140,7 @@ namespace osu.Game.Tests.Visual.Navigation
             AddStep("present beatmap", () => Game.PresentBeatmap(getImport()));
 
             AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is Screens.Select.SongSelect);
-            AddUntilStep("correct beatmap displayed", () => Game.Beatmap.Value.BeatmapSetInfo.ID == getImport().ID);
+            AddUntilStep("correct beatmap displayed", () => Game.Beatmap.Value.BeatmapSetInfo.MatchesOnlineID(getImport()));
             AddAssert("correct ruleset selected", () => Game.Ruleset.Value.ID == getImport().Beatmaps.First().Ruleset.ID);
         }
 

osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs

@@ -96,7 +96,7 @@ namespace osu.Game.Tests.Visual.Navigation
             Player player = null;
             ResultsScreen results = null;
 
-            WorkingBeatmap beatmap() => Game.Beatmap.Value;
+            IWorkingBeatmap beatmap() => Game.Beatmap.Value;
 
             PushAndConfirm(() => new TestPlaySongSelect());
 
@@ -128,7 +128,7 @@ namespace osu.Game.Tests.Visual.Navigation
         {
             Player player = null;
 
-            WorkingBeatmap beatmap() => Game.Beatmap.Value;
+            IWorkingBeatmap beatmap() => Game.Beatmap.Value;
 
             PushAndConfirm(() => new TestPlaySongSelect());
 

osu.Game.Tests/Visual/Playlists/TestScenePlaylistsMatchSettingsOverlay.cs

@@ -73,7 +73,7 @@ namespace osu.Game.Tests.Visual.Playlists
                 RoomManager.CreateRequested = r =>
                 {
                     createdRoom = r;
-                    return true;
+                    return string.Empty;
                 };
             });
 
@@ -82,28 +82,58 @@ namespace osu.Game.Tests.Visual.Playlists
             AddAssert("has correct duration", () => createdRoom.Duration.Value == expectedDuration);
         }
 
+        [Test]
+        public void TestInvalidBeatmapError()
+        {
+            const string not_found_prefix = "beatmaps not found:";
+
+            string errorMesage = null;
+
+            AddStep("setup", () =>
+            {
+                var beatmap = CreateBeatmap(Ruleset.Value).BeatmapInfo;
+
+                SelectedRoom.Value.Name.Value = "Test Room";
+                SelectedRoom.Value.Playlist.Add(new PlaylistItem { Beatmap = { Value = beatmap } });
+
+                errorMesage = $"{not_found_prefix} {beatmap.OnlineID}";
+
+                RoomManager.CreateRequested = _ => errorMesage;
+            });
+
+            AddAssert("error not displayed", () => !settings.ErrorText.IsPresent);
+            AddAssert("playlist item valid", () => SelectedRoom.Value.Playlist[0].Valid.Value);
+
+            AddStep("create room", () => settings.ApplyButton.Action.Invoke());
+
+            AddAssert("error displayed", () => settings.ErrorText.IsPresent);
+            AddAssert("error has custom text", () => settings.ErrorText.Text != errorMesage);
+            AddAssert("playlist item marked invalid", () => !SelectedRoom.Value.Playlist[0].Valid.Value);
+        }
+
         [Test]
         public void TestCreationFailureDisplaysError()
         {
-            bool fail;
+            const string error_message = "failed";
+
+            string failText = error_message;
 
             AddStep("setup", () =>
             {
                 SelectedRoom.Value.Name.Value = "Test Room";
                 SelectedRoom.Value.Playlist.Add(new PlaylistItem { Beatmap = { Value = CreateBeatmap(Ruleset.Value).BeatmapInfo } });
 
-                fail = true;
+                RoomManager.CreateRequested = _ => failText;
-                RoomManager.CreateRequested = _ => !fail;
             });
             AddAssert("error not displayed", () => !settings.ErrorText.IsPresent);
 
             AddStep("create room", () => settings.ApplyButton.Action.Invoke());
             AddAssert("error displayed", () => settings.ErrorText.IsPresent);
-            AddAssert("error has correct text", () => settings.ErrorText.Text == TestRoomManager.FAILED_TEXT);
+            AddAssert("error has correct text", () => settings.ErrorText.Text == error_message);
 
             AddStep("create room no fail", () =>
             {
-                fail = false;
+                failText = string.Empty;
                 settings.ApplyButton.Action.Invoke();
             });
 
@@ -132,9 +162,7 @@ namespace osu.Game.Tests.Visual.Playlists
 
         protected class TestRoomManager : IRoomManager
         {
-            public const string FAILED_TEXT = "failed";
+            public Func<Room, string> CreateRequested;
-
-            public Func<Room, bool> CreateRequested;
 
             public event Action RoomsUpdated
             {
@@ -157,8 +185,10 @@ namespace osu.Game.Tests.Visual.Playlists
                 if (CreateRequested == null)
                     return;
 
-                if (!CreateRequested.Invoke(room))
+                string error = CreateRequested.Invoke(room);
-                    onError?.Invoke(FAILED_TEXT);
+
+                if (!string.IsNullOrEmpty(error))
+                    onError?.Invoke(error);
                 else
                     onSuccess?.Invoke(room);
             }

osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapMetadataDisplay.cs

@@ -88,7 +88,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             });
         }
 
-        private void showMetadataForBeatmap(Func<WorkingBeatmap> getBeatmap)
+        private void showMetadataForBeatmap(Func<IWorkingBeatmap> getBeatmap)
         {
             AddStep("setup display", () =>
             {

osu.Game.Tests/Visual/SongSelect/TestSceneBeatmapRecommendations.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Extensions;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
@@ -102,8 +103,8 @@ namespace osu.Game.Tests.Visual.SongSelect
         {
             BeatmapSetInfo catchSet = null, mixedSet = null;
 
-            AddStep("create catch beatmapset", () => catchSet = importBeatmapSet(0, new[] { new CatchRuleset().RulesetInfo }));
+            AddStep("create catch beatmapset", () => catchSet = importBeatmapSet(1, new[] { new CatchRuleset().RulesetInfo }));
-            AddStep("create mixed beatmapset", () => mixedSet = importBeatmapSet(1,
+            AddStep("create mixed beatmapset", () => mixedSet = importBeatmapSet(2,
                 new[] { new TaikoRuleset().RulesetInfo, new CatchRuleset().RulesetInfo, new ManiaRuleset().RulesetInfo }));
 
             AddAssert("all sets imported", () => ensureAllBeatmapSetsImported(new[] { catchSet, mixedSet }));
@@ -120,8 +121,8 @@ namespace osu.Game.Tests.Visual.SongSelect
         {
             BeatmapSetInfo osuSet = null, mixedSet = null;
 
-            AddStep("create osu! beatmapset", () => osuSet = importBeatmapSet(0, new[] { new OsuRuleset().RulesetInfo }));
+            AddStep("create osu! beatmapset", () => osuSet = importBeatmapSet(1, new[] { new OsuRuleset().RulesetInfo }));
-            AddStep("create mixed beatmapset", () => mixedSet = importBeatmapSet(1,
+            AddStep("create mixed beatmapset", () => mixedSet = importBeatmapSet(2,
                 new[] { new TaikoRuleset().RulesetInfo, new CatchRuleset().RulesetInfo, new ManiaRuleset().RulesetInfo }));
 
             AddAssert("all sets imported", () => ensureAllBeatmapSetsImported(new[] { osuSet, mixedSet }));
@@ -138,8 +139,8 @@ namespace osu.Game.Tests.Visual.SongSelect
         {
             BeatmapSetInfo osuSet = null, mixedSet = null;
 
-            AddStep("create osu! beatmapset", () => osuSet = importBeatmapSet(0, new[] { new OsuRuleset().RulesetInfo }));
+            AddStep("create osu! beatmapset", () => osuSet = importBeatmapSet(1, new[] { new OsuRuleset().RulesetInfo }));
-            AddStep("create mixed beatmapset", () => mixedSet = importBeatmapSet(1,
+            AddStep("create mixed beatmapset", () => mixedSet = importBeatmapSet(2,
                 new[] { new TaikoRuleset().RulesetInfo, new CatchRuleset().RulesetInfo, new TaikoRuleset().RulesetInfo }));
 
             AddAssert("all sets imported", () => ensureAllBeatmapSetsImported(new[] { osuSet, mixedSet }));
@@ -156,8 +157,8 @@ namespace osu.Game.Tests.Visual.SongSelect
         {
             BeatmapSetInfo osuSet = null, maniaSet = null;
 
-            AddStep("create osu! beatmapset", () => osuSet = importBeatmapSet(0, new[] { new OsuRuleset().RulesetInfo }));
+            AddStep("create osu! beatmapset", () => osuSet = importBeatmapSet(1, new[] { new OsuRuleset().RulesetInfo }));
-            AddStep("create mania beatmapset", () => maniaSet = importBeatmapSet(1, Enumerable.Repeat(new ManiaRuleset().RulesetInfo, 10)));
+            AddStep("create mania beatmapset", () => maniaSet = importBeatmapSet(2, Enumerable.Repeat(new ManiaRuleset().RulesetInfo, 10)));
 
             AddAssert("all sets imported", () => ensureAllBeatmapSetsImported(new[] { osuSet, maniaSet }));
 
@@ -203,11 +204,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddStep("present beatmap", () => Game.PresentBeatmap(getImport()));
 
             AddUntilStep("wait for song select", () => Game.ScreenStack.CurrentScreen is Screens.Select.SongSelect);
-            AddUntilStep("recommended beatmap displayed", () =>
+            AddUntilStep("recommended beatmap displayed", () => Game.Beatmap.Value.BeatmapInfo.MatchesOnlineID(getImport().Beatmaps[expectedDiff - 1]));
-            {
-                int? expectedID = getImport().Beatmaps[expectedDiff - 1].OnlineID;
-                return Game.Beatmap.Value.BeatmapInfo.OnlineID == expectedID;
-            });
         }
     }
 }

osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs

@@ -17,6 +17,7 @@ using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Extensions;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
@@ -360,7 +361,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo.Equals(target));
 
             // this is an important check, to make sure updateComponentFromBeatmap() was actually run
-            AddUntilStep("selection shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap.BeatmapInfo.Equals(target));
+            AddUntilStep("selection shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap.BeatmapInfo.MatchesOnlineID(target));
         }
 
         [Test]
@@ -392,7 +393,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddUntilStep("has correct ruleset", () => Ruleset.Value.ID == 0);
 
             // this is an important check, to make sure updateComponentFromBeatmap() was actually run
-            AddUntilStep("selection shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap.BeatmapInfo.Equals(target));
+            AddUntilStep("selection shown on wedge", () => songSelect.CurrentBeatmapDetailsBeatmap.BeatmapInfo.MatchesOnlineID(target));
         }
 
         [Test]
@@ -507,13 +508,13 @@ namespace osu.Game.Tests.Visual.SongSelect
                     i.IsFiltered || i.Item.BeatmapInfo.Ruleset.ID == targetRuleset || i.Item.BeatmapInfo.Ruleset.ID == 0);
             });
 
-            AddUntilStep("carousel has correct", () => songSelect.Carousel.SelectedBeatmapInfo?.OnlineID == target.OnlineID);
+            AddUntilStep("carousel has correct", () => songSelect.Carousel.SelectedBeatmapInfo?.MatchesOnlineID(target) == true);
-            AddUntilStep("game has correct", () => Beatmap.Value.BeatmapInfo.OnlineID == target.OnlineID);
+            AddUntilStep("game has correct", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(target));
 
             AddStep("reset filter text", () => songSelect.FilterControl.ChildrenOfType<SearchTextBox>().First().Text = string.Empty);
 
-            AddAssert("game still correct", () => Beatmap.Value?.BeatmapInfo.OnlineID == target.OnlineID);
+            AddAssert("game still correct", () => Beatmap.Value?.BeatmapInfo.MatchesOnlineID(target) == true);
-            AddAssert("carousel still correct", () => songSelect.Carousel.SelectedBeatmapInfo.OnlineID == target.OnlineID);
+            AddAssert("carousel still correct", () => songSelect.Carousel.SelectedBeatmapInfo.MatchesOnlineID(target));
         }
 
         [Test]
@@ -544,8 +545,8 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("has selection", () => songSelect.Carousel.SelectedBeatmapInfo != null);
 
-            AddUntilStep("carousel has correct", () => songSelect.Carousel.SelectedBeatmapInfo?.OnlineID == target.OnlineID);
+            AddUntilStep("carousel has correct", () => songSelect.Carousel.SelectedBeatmapInfo?.MatchesOnlineID(target) == true);
-            AddUntilStep("game has correct", () => Beatmap.Value.BeatmapInfo.OnlineID == target.OnlineID);
+            AddUntilStep("game has correct", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(target));
 
             AddStep("set filter text", () => songSelect.FilterControl.ChildrenOfType<SearchTextBox>().First().Text = "nononoo");
 
@@ -672,7 +673,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("wait for selection", () => !Beatmap.IsDefault);
 
-            AddStep("record set ID", () => previousSetID = Beatmap.Value.BeatmapSetInfo.ID);
+            AddStep("record set ID", () => previousSetID = ((IBeatmapSetInfo)Beatmap.Value.BeatmapSetInfo).OnlineID);
             AddAssert("selection changed once", () => changeCount == 1);
 
             AddAssert("Check ruleset is osu!", () => Ruleset.Value.ID == 0);
@@ -683,8 +684,8 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("selection changed", () => changeCount > 1);
 
-            AddAssert("Selected beatmap still same set", () => Beatmap.Value.BeatmapSetInfo.ID == previousSetID);
+            AddAssert("Selected beatmap still same set", () => Beatmap.Value.BeatmapSetInfo.OnlineID == previousSetID);
-            AddAssert("Selected beatmap is mania", () => Beatmap.Value.BeatmapInfo.Ruleset.ID == 3);
+            AddAssert("Selected beatmap is mania", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID == 3);
 
             AddAssert("selection changed only fired twice", () => changeCount == 2);
 
@@ -727,7 +728,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             int previousSetID = 0;
 
-            AddStep("record set ID", () => previousSetID = Beatmap.Value.BeatmapSetInfo.ID);
+            AddStep("record set ID", () => previousSetID = ((IBeatmapSetInfo)Beatmap.Value.BeatmapSetInfo).OnlineID);
 
             AddStep("Click on a difficulty", () =>
             {
@@ -738,8 +739,8 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("Check ruleset changed to mania", () => Ruleset.Value.ID == 3);
 
-            AddAssert("Selected beatmap still same set", () => songSelect.Carousel.SelectedBeatmapInfo.BeatmapSet.ID == previousSetID);
+            AddAssert("Selected beatmap still same set", () => songSelect.Carousel.SelectedBeatmapInfo.BeatmapSet.OnlineID == previousSetID);
-            AddAssert("Selected beatmap is mania", () => Beatmap.Value.BeatmapInfo.Ruleset.ID == 3);
+            AddAssert("Selected beatmap is mania", () => Beatmap.Value.BeatmapInfo.Ruleset.OnlineID == 3);
         }
 
         [Test]
@@ -784,7 +785,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("Check ruleset changed to mania", () => Ruleset.Value.ID == 3);
 
-            AddAssert("Check first item in group selected", () => Beatmap.Value.BeatmapInfo.Equals(groupIcon.Items.First().BeatmapInfo));
+            AddAssert("Check first item in group selected", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(groupIcon.Items.First().BeatmapInfo));
         }
 
         [Test]
@@ -815,7 +816,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("wait for results screen presented", () => !songSelect.IsCurrentScreen());
 
-            AddAssert("check beatmap is correct for score", () => Beatmap.Value.BeatmapInfo.Equals(getPresentBeatmap()));
+            AddAssert("check beatmap is correct for score", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(getPresentBeatmap()));
             AddAssert("check ruleset is correct for score", () => Ruleset.Value.ID == 0);
         }
 
@@ -847,7 +848,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             AddUntilStep("wait for results screen presented", () => !songSelect.IsCurrentScreen());
 
-            AddAssert("check beatmap is correct for score", () => Beatmap.Value.BeatmapInfo.Equals(getPresentBeatmap()));
+            AddAssert("check beatmap is correct for score", () => Beatmap.Value.BeatmapInfo.MatchesOnlineID(getPresentBeatmap()));
             AddAssert("check ruleset is correct for score", () => Ruleset.Value.ID == 0);
         }
 
@@ -960,7 +961,7 @@ namespace osu.Game.Tests.Visual.SongSelect
             public new FilterControl FilterControl => base.FilterControl;
 
             public WorkingBeatmap CurrentBeatmap => Beatmap.Value;
-            public WorkingBeatmap CurrentBeatmapDetailsBeatmap => BeatmapDetails.Beatmap;
+            public IWorkingBeatmap CurrentBeatmapDetailsBeatmap => BeatmapDetails.Beatmap;
             public new BeatmapCarousel Carousel => base.Carousel;
 
             public new void PresentScore(ScoreInfo score) => base.PresentScore(score);

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

@@ -199,7 +199,7 @@ namespace osu.Game.Tests.Visual.UserInterface
 
                 public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => throw new NotImplementedException();
 
-                public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => throw new NotImplementedException();
+                public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => throw new NotImplementedException();
 
                 public override string Description { get; } = "test";
                 public override string ShortName { get; } = "tst";

osu.Game/Beatmaps/BeatmapDifficultyCache.cs

@@ -151,7 +151,7 @@ namespace osu.Game.Beatmaps
             }, token, TaskCreationOptions.HideScheduler | TaskCreationOptions.RunContinuationsAsynchronously, updateScheduler);
         }
 
-        public Task<List<TimedDifficultyAttributes>> GetTimedDifficultyAttributesAsync(WorkingBeatmap beatmap, Ruleset ruleset, Mod[] mods, CancellationToken token = default)
+        public Task<List<TimedDifficultyAttributes>> GetTimedDifficultyAttributesAsync(IWorkingBeatmap beatmap, Ruleset ruleset, Mod[] mods, CancellationToken token = default)
         {
             return Task.Factory.StartNew(() => ruleset.CreateDifficultyCalculator(beatmap).CalculateTimed(mods),
                 token,

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -154,14 +154,17 @@ namespace osu.Game.Beatmaps
 
         public bool Equals(BeatmapInfo other)
         {
-            if (ID == 0 || other?.ID == 0)
+            if (ReferenceEquals(this, other)) return true;
-                // one of the two BeatmapInfos we are comparing isn't sourced from a database.
+            if (other == null) return false;
-                // fall back to reference equality.
-                return ReferenceEquals(this, other);
 
-            return ID == other?.ID;
+            if (ID != 0 && other.ID != 0)
+                return ID == other.ID;
+
+            return false;
         }
 
+        public bool Equals(IBeatmapInfo other) => other is BeatmapInfo b && Equals(b);
+
         public bool AudioEquals(BeatmapInfo other) => other != null && BeatmapSet != null && other.BeatmapSet != null &&
                                                       BeatmapSet.Hash == other.BeatmapSet.Hash &&
                                                       (Metadata ?? BeatmapSet.Metadata).AudioFile == (other.Metadata ?? other.BeatmapSet.Metadata).AudioFile;

osu.Game/Beatmaps/BeatmapManager.cs

@@ -179,7 +179,7 @@ namespace osu.Game.Beatmaps
         /// <summary>
         /// A default representation of a WorkingBeatmap to use when no beatmap is available.
         /// </summary>
-        public WorkingBeatmap DefaultBeatmap => workingBeatmapCache.DefaultBeatmap;
+        public IWorkingBeatmap DefaultBeatmap => workingBeatmapCache.DefaultBeatmap;
 
         /// <summary>
         /// Fired when a notification should be presented to the user.

osu.Game/Beatmaps/BeatmapSetInfo.cs

@@ -69,21 +69,17 @@ namespace osu.Game.Beatmaps
 
         public bool Equals(BeatmapSetInfo other)
         {
-            if (other == null)
+            if (ReferenceEquals(this, other)) return true;
-                return false;
+            if (other == null) return false;
 
             if (ID != 0 && other.ID != 0)
                 return ID == other.ID;
 
-            if (OnlineID.HasValue && other.OnlineID.HasValue)
+            return false;
-                return OnlineID == other.OnlineID;
-
-            if (!string.IsNullOrEmpty(Hash) && !string.IsNullOrEmpty(other.Hash))
-                return Hash == other.Hash;
-
-            return ReferenceEquals(this, other);
         }
 
+        public bool Equals(IBeatmapSetInfo other) => other is BeatmapSetInfo b && Equals(b);
+
         #region Implementation of IHasOnlineID
 
         int IHasOnlineID<int>.OnlineID => OnlineID ?? -1;

osu.Game/Beatmaps/Drawables/BeatmapBackgroundSprite.cs

@@ -9,9 +9,9 @@ namespace osu.Game.Beatmaps.Drawables
 {
     public class BeatmapBackgroundSprite : Sprite
     {
-        private readonly WorkingBeatmap working;
+        private readonly IWorkingBeatmap working;
 
-        public BeatmapBackgroundSprite(WorkingBeatmap working)
+        public BeatmapBackgroundSprite(IWorkingBeatmap working)
         {
             if (working == null)
                 throw new ArgumentNullException(nameof(working));

osu.Game/Beatmaps/DummyWorkingBeatmap.cs

@@ -69,7 +69,7 @@ namespace osu.Game.Beatmaps
 
                 public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new DummyBeatmapConverter { Beatmap = beatmap };
 
-                public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => null;
+                public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => null;
 
                 public override string Description => "dummy";
 

osu.Game/Beatmaps/IBeatmapInfo.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Game.Database;
 using osu.Game.Rulesets;
 
@@ -11,7 +12,7 @@ namespace osu.Game.Beatmaps
     /// <summary>
     /// A single beatmap difficulty.
     /// </summary>
-    public interface IBeatmapInfo : IHasOnlineID<int>
+    public interface IBeatmapInfo : IHasOnlineID<int>, IEquatable<IBeatmapInfo>
     {
         /// <summary>
         /// The user-specified name given to this beatmap.

osu.Game/Beatmaps/IBeatmapSetInfo.cs

@@ -12,7 +12,7 @@ namespace osu.Game.Beatmaps
     /// <summary>
     /// A representation of a collection of beatmap difficulties, generally packaged as an ".osz" archive.
     /// </summary>
-    public interface IBeatmapSetInfo : IHasOnlineID<int>
+    public interface IBeatmapSetInfo : IHasOnlineID<int>, IEquatable<IBeatmapSetInfo>
     {
         /// <summary>
         /// The date when this beatmap was imported.

osu.Game/Beatmaps/IWorkingBeatmap.cs

@@ -95,7 +95,7 @@ namespace osu.Game.Beatmaps
         /// <param name="timeout">The maximum length in milliseconds to wait for load to complete. Defaults to 10,000ms.</param>
         /// <returns>The converted <see cref="IBeatmap"/>.</returns>
         /// <exception cref="BeatmapInvalidForRulesetException">If <see cref="Beatmap"/> could not be converted to <paramref name="ruleset"/>.</exception>
-        IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList<Mod> mods = null, TimeSpan? timeout = null);
+        IBeatmap GetPlayableBeatmap(IRulesetInfo ruleset, IReadOnlyList<Mod> mods = null, TimeSpan? timeout = null);
 
         /// <summary>
         /// Load a new audio track instance for this beatmap. This should be called once before accessing <see cref="Track"/>.

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -79,7 +79,7 @@ namespace osu.Game.Beatmaps
         /// <returns>The applicable <see cref="IBeatmapConverter"/>.</returns>
         protected virtual IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap, Ruleset ruleset) => ruleset.CreateBeatmapConverter(beatmap);
 
-        public virtual IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList<Mod> mods = null, TimeSpan? timeout = null)
+        public virtual IBeatmap GetPlayableBeatmap(IRulesetInfo ruleset, IReadOnlyList<Mod> mods = null, TimeSpan? timeout = null)
         {
             using (var cancellationSource = createCancellationTokenSource(timeout))
             {

osu.Game/Collections/BeatmapCollection.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Collections
         /// <summary>
         /// The beatmaps contained by the collection.
         /// </summary>
-        public readonly BindableList<BeatmapInfo> Beatmaps = new BindableList<BeatmapInfo>();
+        public readonly BindableList<IBeatmapInfo> Beatmaps = new BindableList<IBeatmapInfo>();
 
         /// <summary>
         /// The date when this collection was last modified.

osu.Game/Collections/CollectionFilterDropdown.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Collections
         }
 
         private readonly IBindableList<BeatmapCollection> collections = new BindableList<BeatmapCollection>();
-        private readonly IBindableList<BeatmapInfo> beatmaps = new BindableList<BeatmapInfo>();
+        private readonly IBindableList<IBeatmapInfo> beatmaps = new BindableList<IBeatmapInfo>();
         private readonly BindableList<CollectionFilterMenuItem> filters = new BindableList<CollectionFilterMenuItem>();
 
         [Resolved(CanBeNull = true)]
@@ -200,7 +200,7 @@ namespace osu.Game.Collections
             private IBindable<WorkingBeatmap> beatmap { get; set; }
 
             [CanBeNull]
-            private readonly BindableList<BeatmapInfo> collectionBeatmaps;
+            private readonly BindableList<IBeatmapInfo> collectionBeatmaps;
 
             [NotNull]
             private readonly Bindable<string> collectionName;

osu.Game/Database/IHasOnlineID.cs

@@ -1,11 +1,14 @@
 // 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;
+
 #nullable enable
 
 namespace osu.Game.Database
 {
     public interface IHasOnlineID<out T>
+        where T : IEquatable<T>
     {
         /// <summary>
         /// The server-side ID representing this instance, if one exists. Any value 0 or less denotes a missing ID (except in special cases where autoincrement is not used, like rulesets).

osu.Game/Extensions/ModelExtensions.cs

@@ -2,10 +2,14 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets;
 using osu.Game.Scoring;
 using osu.Game.Users;
 
+#nullable enable
+
 namespace osu.Game.Extensions
 {
     public static class ModelExtensions
@@ -22,9 +26,9 @@ namespace osu.Game.Extensions
         /// extension method type inference rules cause this method to call itself and cause a stack overflow.
         /// </para>
         /// </remarks>
-        public static string GetDisplayString(this object model)
+        public static string GetDisplayString(this object? model)
         {
-            string result = null;
+            string? result = null;
 
             switch (model)
             {
@@ -57,5 +61,59 @@ namespace osu.Game.Extensions
             result ??= model?.ToString() ?? @"null";
             return result;
         }
+
+        /// <summary>
+        /// Check whether the online ID of two <see cref="IBeatmapSetInfo"/>s match.
+        /// </summary>
+        /// <param name="instance">The instance to compare.</param>
+        /// <param name="other">The other instance to compare against.</param>
+        /// <returns>Whether online IDs match. If either instance is missing an online ID, this will return false.</returns>
+        public static bool MatchesOnlineID(this IBeatmapSetInfo? instance, IBeatmapSetInfo? other) => matchesOnlineID(instance, other);
+
+        /// <summary>
+        /// Check whether the online ID of two <see cref="IBeatmapInfo"/>s match.
+        /// </summary>
+        /// <param name="instance">The instance to compare.</param>
+        /// <param name="other">The other instance to compare against.</param>
+        /// <returns>Whether online IDs match. If either instance is missing an online ID, this will return false.</returns>
+        public static bool MatchesOnlineID(this IBeatmapInfo? instance, IBeatmapInfo? other) => matchesOnlineID(instance, other);
+
+        /// <summary>
+        /// Check whether the online ID of two <see cref="IRulesetInfo"/>s match.
+        /// </summary>
+        /// <param name="instance">The instance to compare.</param>
+        /// <param name="other">The other instance to compare against.</param>
+        /// <returns>Whether online IDs match. If either instance is missing an online ID, this will return false.</returns>
+        public static bool MatchesOnlineID(this IRulesetInfo? instance, IRulesetInfo? other) => matchesOnlineID(instance, other);
+
+        /// <summary>
+        /// Check whether the online ID of two <see cref="APIUser"/>s match.
+        /// </summary>
+        /// <param name="instance">The instance to compare.</param>
+        /// <param name="other">The other instance to compare against.</param>
+        /// <returns>Whether online IDs match. If either instance is missing an online ID, this will return false.</returns>
+        public static bool MatchesOnlineID(this APIUser? instance, APIUser? other) => matchesOnlineID(instance, other);
+
+        private static bool matchesOnlineID(this IHasOnlineID<long>? instance, IHasOnlineID<long>? other)
+        {
+            if (instance == null || other == null)
+                return false;
+
+            if (instance.OnlineID < 0 || other.OnlineID < 0)
+                return false;
+
+            return instance.OnlineID.Equals(other.OnlineID);
+        }
+
+        private static bool matchesOnlineID(this IHasOnlineID<int>? instance, IHasOnlineID<int>? other)
+        {
+            if (instance == null || other == null)
+                return false;
+
+            if (instance.OnlineID < 0 || other.OnlineID < 0)
+                return false;
+
+            return instance.OnlineID.Equals(other.OnlineID);
+        }
     }
 }

osu.Game/Models/RealmBeatmap.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Models
     [ExcludeFromDynamicCompile]
     [Serializable]
     [MapTo("Beatmap")]
-    public class RealmBeatmap : RealmObject, IHasGuidPrimaryKey, IBeatmapInfo
+    public class RealmBeatmap : RealmObject, IHasGuidPrimaryKey, IBeatmapInfo, IEquatable<RealmBeatmap>
     {
         [PrimaryKey]
         public Guid ID { get; set; } = Guid.NewGuid();
@@ -98,6 +98,16 @@ namespace osu.Game.Models
 
         #endregion
 
+        public bool Equals(RealmBeatmap? other)
+        {
+            if (ReferenceEquals(this, other)) return true;
+            if (other == null) return false;
+
+            return ID == other.ID;
+        }
+
+        public bool Equals(IBeatmapInfo? other) => other is RealmBeatmap b && Equals(b);
+
         public bool AudioEquals(RealmBeatmap? other) => other != null
                                                         && BeatmapSet != null
                                                         && other.BeatmapSet != null

osu.Game/Models/RealmBeatmapSet.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
+using osu.Game.Extensions;
 using Realms;
 
 #nullable enable
@@ -53,25 +54,18 @@ namespace osu.Game.Models
         /// <param name="filename">The name of the file to get the storage path of.</param>
         public string? GetPathForFile(string filename) => Files.SingleOrDefault(f => string.Equals(f.Filename, filename, StringComparison.OrdinalIgnoreCase))?.File.StoragePath;
 
-        public override string ToString() => Metadata?.ToString() ?? base.ToString();
-
         public bool Equals(RealmBeatmapSet? other)
         {
-            if (other == null)
+            if (ReferenceEquals(this, other)) return true;
-                return false;
+            if (other == null) return false;
 
-            if (IsManaged && other.IsManaged)
+            return ID == other.ID;
-                return ID == other.ID;
-
-            if (OnlineID > 0 && other.OnlineID > 0)
-                return OnlineID == other.OnlineID;
-
-            if (!string.IsNullOrEmpty(Hash) && !string.IsNullOrEmpty(other.Hash))
-                return Hash == other.Hash;
-
-            return ReferenceEquals(this, other);
         }
 
+        public override string ToString() => Metadata?.GetDisplayString() ?? base.ToString();
+
+        public bool Equals(IBeatmapSetInfo? other) => other is RealmBeatmapSet b && Equals(b);
+
         IEnumerable<IBeatmapInfo> IBeatmapSetInfo.Beatmaps => Beatmaps;
 
         IEnumerable<INamedFileUsage> IBeatmapSetInfo.Files => Files;

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

@@ -4,6 +4,7 @@
 using System;
 using Newtonsoft.Json;
 using osu.Game.Beatmaps;
+using osu.Game.Extensions;
 using osu.Game.Rulesets;
 
 #nullable enable
@@ -103,5 +104,7 @@ namespace osu.Game.Online.API.Requests.Responses
         public string Hash => throw new NotImplementedException();
 
         #endregion
+
+        public bool Equals(IBeatmapInfo? other) => other is APIBeatmap b && this.MatchesOnlineID(b);
     }
 }

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

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
+using osu.Game.Extensions;
 
 #nullable enable
 
@@ -141,5 +142,7 @@ namespace osu.Game.Online.API.Requests.Responses
         double IBeatmapSetInfo.MaxBPM => BPM;
 
         #endregion
+
+        public bool Equals(IBeatmapSetInfo? other) => other is APIBeatmapSet b && this.MatchesOnlineID(b);
     }
 }

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

@@ -7,6 +7,7 @@ using System.Linq;
 using JetBrains.Annotations;
 using Newtonsoft.Json;
 using osu.Framework.Bindables;
+using osu.Game.Extensions;
 using osu.Game.Users;
 
 namespace osu.Game.Online.API.Requests.Responses
@@ -240,6 +241,6 @@ namespace osu.Game.Online.API.Requests.Responses
 
         public int OnlineID => Id;
 
-        public bool Equals(APIUser other) => OnlineID == other?.OnlineID;
+        public bool Equals(APIUser other) => this.MatchesOnlineID(other);
     }
 }

osu.Game/Online/Chat/NowPlayingCommand.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Online.Chat
             base.LoadComplete();
 
             string verb;
-            BeatmapInfo beatmapInfo;
+            IBeatmapInfo beatmapInfo;
 
             switch (api.Activity.Value)
             {
@@ -57,7 +57,7 @@ namespace osu.Game.Online.Chat
                     break;
             }
 
-            string beatmapString = beatmapInfo.OnlineID.HasValue ? $"[{api.WebsiteRootUrl}/b/{beatmapInfo.OnlineID} {beatmapInfo}]" : beatmapInfo.ToString();
+            string beatmapString = beatmapInfo.OnlineID > 0 ? $"[{api.WebsiteRootUrl}/b/{beatmapInfo.OnlineID} {beatmapInfo}]" : beatmapInfo.ToString();
 
             channelManager.PostMessage($"is {verb} {beatmapString}", true, target);
             Expire();

osu.Game/Online/Chat/StandAloneChatDisplay.cs

@@ -41,8 +41,10 @@ namespace osu.Game.Online.Chat
         /// <param name="postingTextbox">Whether a textbox for posting new messages should be displayed.</param>
         public StandAloneChatDisplay(bool postingTextbox = false)
         {
+            const float corner_radius = 10;
+
             this.postingTextbox = postingTextbox;
-            CornerRadius = 10;
+            CornerRadius = corner_radius;
             Masking = true;
 
             InternalChildren = new Drawable[]
@@ -62,6 +64,7 @@ namespace osu.Game.Online.Chat
                     RelativeSizeAxes = Axes.X,
                     Height = textbox_height,
                     PlaceholderText = "type your message",
+                    CornerRadius = corner_radius,
                     ReleaseFocusOnCommit = false,
                     HoldFocus = true,
                     Anchor = Anchor.BottomLeft,

osu.Game/Online/Rooms/MultiplayerScore.cs

@@ -10,6 +10,7 @@ using Newtonsoft.Json.Converters;
 using osu.Game.Beatmaps;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
@@ -62,7 +63,7 @@ namespace osu.Game.Online.Rooms
         [CanBeNull]
         public MultiplayerScoresAround ScoresAround { get; set; }
 
-        public ScoreInfo CreateScoreInfo(PlaylistItem playlistItem, [NotNull] BeatmapInfo beatmap)
+        public ScoreInfo CreateScoreInfo(RulesetStore rulesets, PlaylistItem playlistItem, [NotNull] BeatmapInfo beatmap)
         {
             var rulesetInstance = playlistItem.Ruleset.Value.CreateInstance();
 
@@ -73,7 +74,7 @@ namespace osu.Game.Online.Rooms
                 MaxCombo = MaxCombo,
                 BeatmapInfo = beatmap,
                 BeatmapInfoID = playlistItem.BeatmapID,
-                Ruleset = playlistItem.Ruleset.Value,
+                Ruleset = rulesets.GetRuleset(playlistItem.RulesetID),
                 RulesetID = playlistItem.RulesetID,
                 Statistics = Statistics,
                 User = User,

osu.Game/Online/Rooms/PlaylistItem.cs

@@ -30,11 +30,16 @@ namespace osu.Game.Online.Rooms
         [JsonProperty("expired")]
         public bool Expired { get; set; }
 
+        [JsonIgnore]
+        public IBindable<bool> Valid => valid;
+
+        private readonly Bindable<bool> valid = new BindableBool(true);
+
         [JsonIgnore]
         public readonly Bindable<IBeatmapInfo> Beatmap = new Bindable<IBeatmapInfo>();
 
         [JsonIgnore]
-        public readonly Bindable<RulesetInfo> Ruleset = new Bindable<RulesetInfo>();
+        public readonly Bindable<IRulesetInfo> Ruleset = new Bindable<IRulesetInfo>();
 
         [JsonIgnore]
         public readonly BindableList<Mod> AllowedMods = new BindableList<Mod>();
@@ -66,9 +71,11 @@ namespace osu.Game.Online.Rooms
         public PlaylistItem()
         {
             Beatmap.BindValueChanged(beatmap => BeatmapID = beatmap.NewValue?.OnlineID ?? -1);
-            Ruleset.BindValueChanged(ruleset => RulesetID = ruleset.NewValue?.ID ?? 0);
+            Ruleset.BindValueChanged(ruleset => RulesetID = ruleset.NewValue?.OnlineID ?? 0);
         }
 
+        public void MarkInvalid() => valid.Value = false;
+
         public void MapObjects(RulesetStore rulesets)
         {
             Beatmap.Value ??= apiBeatmap;

osu.Game/Overlays/BeatmapListing/Panels/BeatmapPanelDownloadButton.cs

@@ -8,6 +8,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Extensions;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online;
@@ -80,7 +81,7 @@ namespace osu.Game.Overlays.BeatmapListing.Panels
                     case DownloadState.LocallyAvailable:
                         Predicate<BeatmapInfo> findPredicate = null;
                         if (SelectedBeatmap.Value != null)
-                            findPredicate = b => b.OnlineID == SelectedBeatmap.Value.OnlineID;
+                            findPredicate = b => b.MatchesOnlineID(SelectedBeatmap.Value);
 
                         game?.PresentBeatmap(beatmapSet, findPredicate);
                         break;

osu.Game/Overlays/BeatmapSet/BeatmapPicker.cs

@@ -14,6 +14,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
+using osu.Game.Extensions;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -166,7 +167,7 @@ namespace osu.Game.Overlays.BeatmapSet
             if (BeatmapSet != null)
             {
                 Difficulties.ChildrenEnumerable = BeatmapSet.Beatmaps
-                                                            .Where(b => b.Ruleset.OnlineID == ruleset.Value?.OnlineID)
+                                                            .Where(b => b.Ruleset.MatchesOnlineID(ruleset.Value))
                                                             .OrderBy(b => b.StarRating)
                                                             .Select(b => new DifficultySelectorButton(b)
                                                             {

osu.Game/Overlays/BeatmapSet/BeatmapRulesetTabItem.cs

@@ -7,6 +7,7 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Game.Extensions;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Online.API.Requests.Responses;
@@ -64,7 +65,7 @@ namespace osu.Game.Overlays.BeatmapSet
 
             BeatmapSet.BindValueChanged(setInfo =>
             {
-                int beatmapsCount = setInfo.NewValue?.Beatmaps.Count(b => b.Ruleset.OnlineID == Value.OnlineID) ?? 0;
+                int beatmapsCount = setInfo.NewValue?.Beatmaps.Count(b => b.Ruleset.MatchesOnlineID(Value)) ?? 0;
 
                 count.Text = beatmapsCount.ToString();
                 countContainer.FadeTo(beatmapsCount > 0 ? 1 : 0);

osu.Game/Overlays/Music/Playlist.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Overlays.Music
             var items = (SearchContainer<RearrangeableListItem<BeatmapSetInfo>>)ListContainer;
 
             foreach (var item in items.OfType<PlaylistItem>())
-                item.InSelectedCollection = criteria.Collection?.Beatmaps.Any(b => b.BeatmapSet.Equals(item.Model)) ?? true;
+                item.InSelectedCollection = criteria.Collection?.Beatmaps.Any(b => item.Model.Equals(b.BeatmapSet)) ?? true;
 
             items.SearchTerm = criteria.SearchText;
         }

osu.Game/Overlays/Profile/Header/Components/SupporterIcon.cs

@@ -5,22 +5,23 @@ using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
 using osu.Framework.Localisation;
 using osu.Game.Graphics;
+using osu.Game.Graphics.Containers;
 using osu.Game.Resources.Localisation.Web;
 
 namespace osu.Game.Overlays.Profile.Header.Components
 {
-    public class SupporterIcon : CompositeDrawable, IHasTooltip
+    public class SupporterIcon : OsuClickableContainer
     {
         private readonly Box background;
         private readonly FillFlowContainer iconContainer;
         private readonly CircularContainer content;
 
-        public LocalisableString TooltipText => UsersStrings.ShowIsSupporter;
+        public override LocalisableString TooltipText => UsersStrings.ShowIsSupporter;
 
         public int SupportLevel
         {
@@ -56,7 +57,7 @@ namespace osu.Game.Overlays.Profile.Header.Components
         {
             AutoSizeAxes = Axes.X;
 
-            InternalChild = content = new CircularContainer
+            Child = content = new CircularContainer
             {
                 RelativeSizeAxes = Axes.Y,
                 AutoSizeAxes = Axes.X,
@@ -78,10 +79,27 @@ namespace osu.Game.Overlays.Profile.Header.Components
             };
         }
 
-        [BackgroundDependencyLoader]
+        [Resolved]
-        private void load(OsuColour colours)
+        private OsuColour colours { get; set; }
+
+        [BackgroundDependencyLoader(true)]
+        private void load(OsuGame game)
         {
             background.Colour = colours.Pink;
+
+            Action = () => game?.OpenUrlExternally(@"/home/support");
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            background.FadeColour(colours.PinkLight, 500, Easing.OutQuint);
+            return base.OnHover(e);
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            background.FadeColour(colours.Pink, 500, Easing.OutQuint);
+            base.OnHoverLost(e);
         }
     }
 }

osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs

@@ -1,28 +1,87 @@
 // 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 Newtonsoft.Json;
 using osu.Game.Rulesets.Difficulty.Skills;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Difficulty
 {
+    /// <summary>
+    /// Describes the difficulty of a beatmap, as output by a <see cref="DifficultyCalculator"/>.
+    /// </summary>
+    [JsonObject(MemberSerialization.OptIn)]
     public class DifficultyAttributes
     {
+        protected const int ATTRIB_ID_AIM = 1;
+        protected const int ATTRIB_ID_SPEED = 3;
+        protected const int ATTRIB_ID_OVERALL_DIFFICULTY = 5;
+        protected const int ATTRIB_ID_APPROACH_RATE = 7;
+        protected const int ATTRIB_ID_MAX_COMBO = 9;
+        protected const int ATTRIB_ID_STRAIN = 11;
+        protected const int ATTRIB_ID_GREAT_HIT_WINDOW = 13;
+        protected const int ATTRIB_ID_SCORE_MULTIPLIER = 15;
+        protected const int ATTRIB_ID_FLASHLIGHT = 17;
+        protected const int ATTRIB_ID_SLIDER_FACTOR = 19;
+
+        /// <summary>
+        /// The mods which were applied to the beatmap.
+        /// </summary>
         public Mod[] Mods { get; set; }
+
+        /// <summary>
+        /// The skills resulting from the difficulty calculation.
+        /// </summary>
         public Skill[] Skills { get; set; }
 
+        /// <summary>
+        /// The combined star rating of all skill.
+        /// </summary>
+        [JsonProperty("star_rating", Order = -3)]
         public double StarRating { get; set; }
+
+        /// <summary>
+        /// The maximum achievable combo.
+        /// </summary>
+        [JsonProperty("max_combo", Order = -2)]
         public int MaxCombo { get; set; }
 
+        /// <summary>
+        /// Creates new <see cref="DifficultyAttributes"/>.
+        /// </summary>
         public DifficultyAttributes()
         {
         }
 
+        /// <summary>
+        /// Creates new <see cref="DifficultyAttributes"/>.
+        /// </summary>
+        /// <param name="mods">The mods which were applied to the beatmap.</param>
+        /// <param name="skills">The skills resulting from the difficulty calculation.</param>
+        /// <param name="starRating">The combined star rating of all skills.</param>
         public DifficultyAttributes(Mod[] mods, Skill[] skills, double starRating)
         {
             Mods = mods;
             Skills = skills;
             StarRating = starRating;
         }
+
+        /// <summary>
+        /// Converts this <see cref="DifficultyAttributes"/> to osu-web compatible database attribute mappings.
+        /// </summary>
+        /// <remarks>
+        /// See: osu_difficulty_attribs table.
+        /// </remarks>
+        public virtual IEnumerable<(int attributeId, object value)> ToDatabaseAttributes() => Enumerable.Empty<(int, object)>();
+
+        /// <summary>
+        /// Reads osu-web database attribute mappings into this <see cref="DifficultyAttributes"/> object.
+        /// </summary>
+        /// <param name="values">The attribute mappings.</param>
+        public virtual void FromDatabaseAttributes(IReadOnlyDictionary<int, double> values)
+        {
+        }
     }
 }

osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs

@@ -26,10 +26,10 @@ namespace osu.Game.Rulesets.Difficulty
         private Mod[] playableMods;
         private double clockRate;
 
-        private readonly Ruleset ruleset;
+        private readonly IRulesetInfo ruleset;
-        private readonly WorkingBeatmap beatmap;
+        private readonly IWorkingBeatmap beatmap;
 
-        protected DifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+        protected DifficultyCalculator(IRulesetInfo ruleset, IWorkingBeatmap beatmap)
         {
             this.ruleset = ruleset;
             this.beatmap = beatmap;
@@ -116,7 +116,7 @@ namespace osu.Game.Rulesets.Difficulty
         {
             playableMods = mods.Select(m => m.DeepClone()).ToArray();
 
-            Beatmap = beatmap.GetPlayableBeatmap(ruleset.RulesetInfo, playableMods);
+            Beatmap = beatmap.GetPlayableBeatmap(ruleset, playableMods);
 
             var track = new TrackVirtual(10000);
             playableMods.OfType<IApplicableToTrack>().ForEach(m => m.ApplyToTrack(track));

osu.Game/Rulesets/Ruleset.cs

@@ -222,7 +222,7 @@ namespace osu.Game.Rulesets
         /// <returns>The <see cref="IBeatmapProcessor"/>.</returns>
         public virtual IBeatmapProcessor CreateBeatmapProcessor(IBeatmap beatmap) => null;
 
-        public abstract DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap);
+        public abstract DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap);
 
         /// <summary>
         /// Optionally creates a <see cref="PerformanceCalculator"/> to generate performance data from the provided score.
@@ -240,7 +240,7 @@ namespace osu.Game.Rulesets
         /// <param name="score">The score to be processed.</param>
         /// <returns>A performance calculator instance for the provided score.</returns>
         [CanBeNull]
-        public PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score)
+        public PerformanceCalculator CreatePerformanceCalculator(IWorkingBeatmap beatmap, ScoreInfo score)
         {
             var difficultyCalculator = CreateDifficultyCalculator(beatmap);
             var difficultyAttributes = difficultyCalculator.Calculate(score.Mods);

osu.Game/Scoring/Legacy/LegacyScoreDecoder.cs

@@ -115,7 +115,7 @@ namespace osu.Game.Scoring.Legacy
                 }
             }
 
-            CalculateAccuracy(score.ScoreInfo);
+            PopulateAccuracy(score.ScoreInfo);
 
             // before returning for database import, we must restore the database-sourced BeatmapInfo.
             // if not, the clone operation in GetPlayableBeatmap will cause a dereference and subsequent database exception.
@@ -124,7 +124,14 @@ namespace osu.Game.Scoring.Legacy
             return score;
         }
 
-        protected void CalculateAccuracy(ScoreInfo score)
+        /// <summary>
+        /// Populates the accuracy of a given <see cref="ScoreInfo"/> from its contained statistics.
+        /// </summary>
+        /// <remarks>
+        /// Legacy use only.
+        /// </remarks>
+        /// <param name="score">The <see cref="ScoreInfo"/> to populate.</param>
+        public static void PopulateAccuracy(ScoreInfo score)
         {
             int countMiss = score.GetCountMiss() ?? 0;
             int count50 = score.GetCount50() ?? 0;

osu.Game/Screens/OnlinePlay/DrawableRoomPlaylistItem.cs

@@ -13,7 +13,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
-using osu.Framework.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Drawables;
 using osu.Game.Graphics;
@@ -47,8 +46,10 @@ namespace osu.Game.Screens.OnlinePlay
         private ExplicitContentBeatmapPill explicitContentPill;
         private ModDisplay modDisplay;
 
+        private readonly IBindable<bool> valid = new Bindable<bool>();
+
         private readonly Bindable<IBeatmapInfo> beatmap = new Bindable<IBeatmapInfo>();
-        private readonly Bindable<RulesetInfo> ruleset = new Bindable<RulesetInfo>();
+        private readonly Bindable<IRulesetInfo> ruleset = new Bindable<IRulesetInfo>();
         private readonly BindableList<Mod> requiredMods = new BindableList<Mod>();
 
         public readonly PlaylistItem Item;
@@ -68,6 +69,7 @@ namespace osu.Game.Screens.OnlinePlay
             this.allowSelection = allowSelection;
 
             beatmap.BindTo(item.Beatmap);
+            valid.BindTo(item.Valid);
             ruleset.BindTo(item.Ruleset);
             requiredMods.BindTo(item.RequiredMods);
 
@@ -77,8 +79,11 @@ namespace osu.Game.Screens.OnlinePlay
                 Colour = OsuColour.Gray(0.5f);
         }
 
+        [Resolved]
+        private OsuColour colours { get; set; }
+
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private void load()
         {
             if (!allowEdit)
                 HandleColour = HandleColour.Opacity(0);
@@ -90,27 +95,43 @@ namespace osu.Game.Screens.OnlinePlay
         {
             base.LoadComplete();
 
-            SelectedItem.BindValueChanged(selected => maskingContainer.BorderThickness = selected.NewValue == Model ? 5 : 0, true);
+            SelectedItem.BindValueChanged(selected =>
+            {
+                bool isCurrent = selected.NewValue == Model;
 
-            beatmap.BindValueChanged(_ => scheduleRefresh());
+                if (!valid.Value)
-            ruleset.BindValueChanged(_ => scheduleRefresh());
+                {
+                    // Don't allow selection when not valid.
+                    if (isCurrent)
+                    {
+                        SelectedItem.Value = selected.OldValue;
+                    }
 
-            requiredMods.CollectionChanged += (_, __) => scheduleRefresh();
+                    // Don't update border when not valid (the border is displaying this fact).
+                    return;
+                }
+
+                maskingContainer.BorderThickness = isCurrent ? 5 : 0;
+            }, true);
+
+            beatmap.BindValueChanged(_ => Scheduler.AddOnce(refresh));
+            ruleset.BindValueChanged(_ => Scheduler.AddOnce(refresh));
+            valid.BindValueChanged(_ => Scheduler.AddOnce(refresh));
+            requiredMods.CollectionChanged += (_, __) => Scheduler.AddOnce(refresh);
 
             refresh();
         }
 
-        private ScheduledDelegate scheduledRefresh;
         private PanelBackground panelBackground;
 
-        private void scheduleRefresh()
-        {
-            scheduledRefresh?.Cancel();
-            scheduledRefresh = Schedule(refresh);
-        }
-
         private void refresh()
         {
+            if (!valid.Value)
+            {
+                maskingContainer.BorderThickness = 5;
+                maskingContainer.BorderColour = colours.Red;
+            }
+
             difficultyIconContainer.Child = new DifficultyIcon(Item.Beatmap.Value, ruleset.Value, requiredMods, performBackgroundDifficultyLookup: false) { Size = new Vector2(32) };
 
             panelBackground.Beatmap.Value = Item.Beatmap.Value;
@@ -283,7 +304,7 @@ namespace osu.Game.Screens.OnlinePlay
 
         protected override bool OnClick(ClickEvent e)
         {
-            if (allowSelection)
+            if (allowSelection && valid.Value)
                 SelectedItem.Value = Model;
             return true;
         }

osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs

@@ -82,7 +82,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
                 {
                     bool matchingFilter = true;
 
-                    matchingFilter &= r.Room.Playlist.Count == 0 || criteria.Ruleset == null || r.Room.Playlist.Any(i => i.Ruleset.Value.Equals(criteria.Ruleset));
+                    matchingFilter &= r.Room.Playlist.Count == 0 || criteria.Ruleset == null || r.Room.Playlist.Any(i => i.Ruleset.Value.MatchesOnlineID(criteria.Ruleset));
 
                     if (!string.IsNullOrEmpty(criteria.SearchString))
                         matchingFilter &= r.FilterTerms.Any(term => term.Contains(criteria.SearchString, StringComparison.InvariantCultureIgnoreCase));

osu.Game/Screens/OnlinePlay/Match/RoomSubScreen.cs

@@ -18,6 +18,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Online.Rooms;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Mods;
+using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.OnlinePlay.Match.Components;
 
@@ -59,6 +60,9 @@ namespace osu.Game.Screens.OnlinePlay.Match
         [Resolved]
         private BeatmapManager beatmapManager { get; set; }
 
+        [Resolved]
+        private RulesetStore rulesets { get; set; }
+
         [Resolved(canBeNull: true)]
         protected OnlinePlayScreen ParentScreen { get; private set; }
 
@@ -344,7 +348,7 @@ namespace osu.Game.Screens.OnlinePlay.Match
 
             UpdateMods();
 
-            Ruleset.Value = selected.Ruleset.Value;
+            Ruleset.Value = rulesets.GetRuleset(selected.RulesetID);
 
             if (!selected.AllowedMods.Any())
             {

osu.Game/Screens/OnlinePlay/Playlists/PlaylistsPlayer.cs

@@ -8,6 +8,7 @@ using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Screens;
+using osu.Game.Extensions;
 using osu.Game.Online.Rooms;
 using osu.Game.Rulesets;
 using osu.Game.Scoring;
@@ -32,10 +33,10 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
         private void load(IBindable<RulesetInfo> ruleset)
         {
             // Sanity checks to ensure that PlaylistsPlayer matches the settings for the current PlaylistItem
-            if (Beatmap.Value.BeatmapInfo.OnlineID != PlaylistItem.Beatmap.Value.OnlineID)
+            if (!Beatmap.Value.BeatmapInfo.MatchesOnlineID(PlaylistItem.Beatmap.Value))
                 throw new InvalidOperationException("Current Beatmap does not match PlaylistItem's Beatmap");
 
-            if (ruleset.Value.ID != PlaylistItem.Ruleset.Value.ID)
+            if (!ruleset.Value.MatchesOnlineID(PlaylistItem.Ruleset.Value))
                 throw new InvalidOperationException("Current Ruleset does not match PlaylistItem's Ruleset");
 
             if (!PlaylistItem.RequiredMods.All(m => Mods.Value.Any(m.Equals)))

osu.Game/Screens/OnlinePlay/Playlists/PlaylistsResultsScreen.cs

@@ -12,6 +12,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Online.Rooms;
+using osu.Game.Rulesets;
 using osu.Game.Scoring;
 using osu.Game.Screens.Ranking;
 
@@ -35,6 +36,9 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
         [Resolved]
         private ScoreManager scoreManager { get; set; }
 
+        [Resolved]
+        private RulesetStore rulesets { get; set; }
+
         public PlaylistsResultsScreen(ScoreInfo score, long roomId, PlaylistItem playlistItem, bool allowRetry, bool allowWatchingReplay = true)
             : base(score, allowRetry, allowWatchingReplay)
         {
@@ -169,7 +173,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
         /// <param name="pivot">An optional pivot around which the scores were retrieved.</param>
         private void performSuccessCallback([NotNull] Action<IEnumerable<ScoreInfo>> callback, [NotNull] List<MultiplayerScore> scores, [CanBeNull] MultiplayerScores pivot = null)
         {
-            var scoreInfos = scores.Select(s => s.CreateScoreInfo(playlistItem, Beatmap.Value.BeatmapInfo)).ToArray();
+            var scoreInfos = scores.Select(s => s.CreateScoreInfo(rulesets, playlistItem, Beatmap.Value.BeatmapInfo)).ToArray();
 
             // Score panels calculate total score before displaying, which can take some time. In order to count that calculation as part of the loading spinner display duration,
             // calculate the total scores locally before invoking the success callback.

osu.Game/Screens/OnlinePlay/Playlists/PlaylistsRoomSettingsOverlay.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Specialized;
+using System.Linq;
 using Humanizer;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -204,7 +205,7 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
                                                                 {
                                                                     new Drawable[]
                                                                     {
-                                                                        playlist = new DrawableRoomPlaylist(true, true) { RelativeSizeAxes = Axes.Both }
+                                                                        playlist = new DrawableRoomPlaylist(true, false) { RelativeSizeAxes = Axes.Both }
                                                                     },
                                                                     new Drawable[]
                                                                     {
@@ -339,9 +340,8 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 
                 Duration.Value = DurationField.Current.Value;
 
-                manager?.CreateRoom(room, onSuccess, onError);
-
                 loadingLayer.Show();
+                manager?.CreateRoom(room, onSuccess, onError);
             }
 
             private void hideError() => ErrorText.FadeOut(50);
@@ -350,9 +350,31 @@ namespace osu.Game.Screens.OnlinePlay.Playlists
 
             private void onError(string text)
             {
-                ErrorText.Text = text;
+                // see https://github.com/ppy/osu-web/blob/2c97aaeb64fb4ed97c747d8383a35b30f57428c7/app/Models/Multiplayer/PlaylistItem.php#L48.
-                ErrorText.FadeIn(50);
+                const string not_found_prefix = "beatmaps not found:";
 
+                if (text.StartsWith(not_found_prefix, StringComparison.Ordinal))
+                {
+                    ErrorText.Text = "One or more beatmaps were not available online. Please remove or replace the highlighted items.";
+
+                    int[] invalidBeatmapIDs = text
+                                              .Substring(not_found_prefix.Length + 1)
+                                              .Split(", ")
+                                              .Select(int.Parse)
+                                              .ToArray();
+
+                    foreach (var item in Playlist)
+                    {
+                        if (invalidBeatmapIDs.Contains(item.BeatmapID))
+                            item.MarkInvalid();
+                    }
+                }
+                else
+                {
+                    ErrorText.Text = text;
+                }
+
+                ErrorText.FadeIn(50);
                 loadingLayer.Hide();
             }
         }

osu.Game/Screens/Play/BeatmapMetadataDisplay.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Screens.Play
     /// </summary>
     public class BeatmapMetadataDisplay : Container
     {
-        private readonly WorkingBeatmap beatmap;
+        private readonly IWorkingBeatmap beatmap;
         private readonly Bindable<IReadOnlyList<Mod>> mods;
         private readonly Drawable logoFacade;
         private LoadingSpinner loading;
@@ -43,7 +43,7 @@ namespace osu.Game.Screens.Play
             }
         }
 
-        public BeatmapMetadataDisplay(WorkingBeatmap beatmap, Bindable<IReadOnlyList<Mod>> mods, Drawable logoFacade)
+        public BeatmapMetadataDisplay(IWorkingBeatmap beatmap, Bindable<IReadOnlyList<Mod>> mods, Drawable logoFacade)
         {
             this.beatmap = beatmap;
             this.logoFacade = logoFacade;

osu.Game/Screens/Play/HUD/PerformancePointsCounter.cs

@@ -216,7 +216,7 @@ namespace osu.Game.Screens.Play.HUD
                 this.gameplayBeatmap = gameplayBeatmap;
             }
 
-            public override IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList<Mod> mods = null, TimeSpan? timeout = null)
+            public override IBeatmap GetPlayableBeatmap(IRulesetInfo ruleset, IReadOnlyList<Mod> mods = null, TimeSpan? timeout = null)
                 => gameplayBeatmap;
 
             protected override IBeatmap GetBeatmap() => gameplayBeatmap;

osu.Game/Screens/Play/Player.cs

@@ -354,7 +354,7 @@ namespace osu.Game.Screens.Play
         private Drawable createUnderlayComponents() =>
             DimmableStoryboard = new DimmableStoryboard(Beatmap.Value.Storyboard) { RelativeSizeAxes = Axes.Both };
 
-        private Drawable createGameplayComponents(WorkingBeatmap working, IBeatmap playableBeatmap) => new ScalingContainer(ScalingMode.Gameplay)
+        private Drawable createGameplayComponents(IWorkingBeatmap working, IBeatmap playableBeatmap) => new ScalingContainer(ScalingMode.Gameplay)
         {
             Children = new Drawable[]
             {
@@ -372,7 +372,7 @@ namespace osu.Game.Screens.Play
             }
         };
 
-        private Drawable createOverlayComponents(WorkingBeatmap working)
+        private Drawable createOverlayComponents(IWorkingBeatmap working)
         {
             var container = new Container
             {

osu.Game/Screens/Select/BeatmapInfoWedgeBackground.cs

@@ -15,9 +15,9 @@ namespace osu.Game.Screens.Select
 {
     internal class BeatmapInfoWedgeBackground : CompositeDrawable
     {
-        private readonly WorkingBeatmap beatmap;
+        private readonly IWorkingBeatmap beatmap;
 
-        public BeatmapInfoWedgeBackground(WorkingBeatmap beatmap)
+        public BeatmapInfoWedgeBackground(IWorkingBeatmap beatmap)
         {
             this.beatmap = beatmap;
         }

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

@@ -14,7 +14,7 @@ namespace osu.Game.Screens.Select.Carousel
 {
     public class SetPanelBackground : BufferedContainer
     {
-        public SetPanelBackground(WorkingBeatmap working)
+        public SetPanelBackground(IWorkingBeatmap working)
             : base(cachedFrameBuffer: true)
         {
             RedrawOnScale = false;

osu.Game/Screens/Select/Leaderboards/BeatmapLeaderboard.cs

@@ -116,6 +116,8 @@ namespace osu.Game.Screens.Select.Leaderboards
             loadCancellationSource?.Cancel();
             loadCancellationSource = new CancellationTokenSource();
 
+            var cancellationToken = loadCancellationSource.Token;
+
             if (BeatmapInfo == null)
             {
                 PlaceholderState = PlaceholderState.NoneSelected;
@@ -140,7 +142,7 @@ namespace osu.Game.Screens.Select.Leaderboards
                     scores = scores.Where(s => s.Mods.Any(m => selectedMods.Contains(m.Acronym)));
                 }
 
-                scoreManager.OrderByTotalScoreAsync(scores.ToArray(), loadCancellationSource.Token)
+                scoreManager.OrderByTotalScoreAsync(scores.ToArray(), cancellationToken)
                             .ContinueWith(ordered => scoresCallback?.Invoke(ordered.Result), TaskContinuationOptions.OnlyOnRanToCompletion);
 
                 return null;
@@ -176,10 +178,10 @@ namespace osu.Game.Screens.Select.Leaderboards
 
             req.Success += r =>
             {
-                scoreManager.OrderByTotalScoreAsync(r.Scores.Select(s => s.CreateScoreInfo(rulesets, BeatmapInfo)).ToArray(), loadCancellationSource.Token)
+                scoreManager.OrderByTotalScoreAsync(r.Scores.Select(s => s.CreateScoreInfo(rulesets, BeatmapInfo)).ToArray(), cancellationToken)
                             .ContinueWith(ordered => Schedule(() =>
                             {
-                                if (loadCancellationSource.IsCancellationRequested)
+                                if (cancellationToken.IsCancellationRequested)
                                     return;
 
                                 scoresCallback?.Invoke(ordered.Result);

osu.Game/Screens/Select/SongSelect.cs

@@ -671,7 +671,7 @@ namespace osu.Game.Screens.Select
             music.TrackChanged -= ensureTrackLooping;
         }
 
-        private void ensureTrackLooping(WorkingBeatmap beatmap, TrackChangeDirection changeDirection)
+        private void ensureTrackLooping(IWorkingBeatmap beatmap, TrackChangeDirection changeDirection)
             => beatmap.PrepareTrackForPreviewLooping();
 
         public override bool OnBackButton()

osu.Game/Storyboards/Storyboard.cs

@@ -89,7 +89,7 @@ namespace osu.Game.Storyboards
             }
         }
 
-        public DrawableStoryboard CreateDrawable(WorkingBeatmap working = null) =>
+        public DrawableStoryboard CreateDrawable(IWorkingBeatmap working = null) =>
             new DrawableStoryboard(this);
 
         public Drawable CreateSpriteFromResourcePath(string path, TextureStore textureStore)

osu.Game/Tests/Beatmaps/DifficultyCalculatorTest.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Tests.Beatmaps
             Assert.That(CreateDifficultyCalculator(getBeatmap(name)).Calculate(mods).StarRating, Is.EqualTo(expected).Within(0.00001));
         }
 
-        private WorkingBeatmap getBeatmap(string name)
+        private IWorkingBeatmap getBeatmap(string name)
         {
             using (var resStream = openResource($"{resource_namespace}.{name}.osu"))
             using (var stream = new LineBufferedReader(resStream))
@@ -53,7 +53,7 @@ namespace osu.Game.Tests.Beatmaps
             return Assembly.LoadFrom(Path.Combine(localPath, $"{ResourceAssembly}.dll")).GetManifestResourceStream($@"{ResourceAssembly}.Resources.{name}");
         }
 
-        protected abstract DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap);
+        protected abstract DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap);
 
         protected abstract Ruleset CreateRuleset();
     }

osu.Game/Updater/GitHubAsset.cs

@@ -0,0 +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 Newtonsoft.Json;
+
+namespace osu.Game.Updater
+{
+    public class GitHubAsset
+    {
+        [JsonProperty("name")]
+        public string Name { get; set; }
+
+        [JsonProperty("browser_download_url")]
+        public string BrowserDownloadUrl { get; set; }
+    }
+}

osu.Game/Updater/GitHubRelease.cs

@@ -0,0 +1,20 @@
+// 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 Newtonsoft.Json;
+
+namespace osu.Game.Updater
+{
+    public class GitHubRelease
+    {
+        [JsonProperty("html_url")]
+        public string HtmlUrl { get; set; }
+
+        [JsonProperty("tag_name")]
+        public string TagName { get; set; }
+
+        [JsonProperty("assets")]
+        public List<GitHubAsset> Assets { get; set; }
+    }
+}