Merge pull request #2802 from smoogipoo/diffcalc-rework

Rework difficulty calculators to better support mods and attributes

COMPILING.md

@@ -1,36 +0,0 @@
-# Linux
-### 1. Requirements:
-Mono >= 5.4.0 (>= 5.8.0 recommended)
-Please check [here](http://www.mono-project.com/download/) for stable or [here](http://www.mono-project.com/download/alpha/) for an alpha release.  
-NuGet >= 4.4.0  
-msbuild  
-git
-
-### 2. Cloning project
-Clone the entire repository with submodules using
-```
-git clone https://github.com/ppy/osu --recursive
-```
-Then restore NuGet packages from the repository
-```
-nuget restore
-```
-### 3. Compiling
-Simply run `msbuild` where `osu.sln` is located, this will create all binaries in `osu/osu.Desktop/bin/Debug`.
-### 4. Optimizing
-If you want additional performance you can change build type to Release with
-```
-msbuild -p:Configuration=Release
-```
-Additionally, mono provides an AOT utility which attempts to precompile binaries. You can utilize that by running
-```
-mono --aot ./osu\!.exe
-```
-### 5. Troubleshooting
-You may run into trouble with NuGet versioning, as the one in packaging system is almost always out of date. Simply run 
-```
-nuget
-sudo nuget update -self
-```
-**Warning** NuGet creates few config files when it's run for the first time.
-Do not run NuGet as root on the first run or you might run into very peculiar issues.

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

@@ -1,16 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-
-namespace osu.Game.Rulesets.Catch.Tests
-{
-    [TestFixture]
-    public class TestCasePerformancePoints : Game.Tests.Visual.TestCasePerformancePoints
-    {
-        public TestCasePerformancePoints()
-            : base(new CatchRuleset())
-        {
-        }
-    }
-}

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -82,56 +82,25 @@ namespace osu.Game.Rulesets.Catch
                     {
                         new CatchModEasy(),
                         new CatchModNoFail(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new CatchModHalfTime(),
-                                new CatchModDaycore(),
-                            },
-                        },
+                        new MultiMod(new CatchModHalfTime(), new CatchModDaycore())
                     };
-
                 case ModType.DifficultyIncrease:
                     return new Mod[]
                     {
                         new CatchModHardRock(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new CatchModSuddenDeath(),
-                                new CatchModPerfect(),
-                            },
-                        },
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new CatchModDoubleTime(),
-                                new CatchModNightcore(),
-                            },
-                        },
+                        new MultiMod(new CatchModSuddenDeath(), new CatchModPerfect()),
+                        new MultiMod(new CatchModDoubleTime(), new CatchModNightcore()),
                         new CatchModHidden(),
                         new CatchModFlashlight(),
                     };
-
                 case ModType.Special:
                     return new Mod[]
                     {
                         new CatchModRelax(),
                         null,
                         null,
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new CatchModAutoplay(),
-                                new ModCinema(),
-                            },
-                        },
+                        new MultiMod(new CatchModAutoplay(), new ModCinema()),
                     };
-
                 default:
                     return new Mod[] { };
             }
@@ -143,7 +112,7 @@ namespace osu.Game.Rulesets.Catch
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_fruits_o };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(IBeatmap beatmap, Mod[] mods = null) => new CatchDifficultyCalculator(beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(this, beatmap);
 
         public override int? LegacyID => 2;
 

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

@@ -1,18 +1,19 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Collections.Generic;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Catch.Difficulty
 {
     public class CatchDifficultyCalculator : DifficultyCalculator
     {
-        public CatchDifficultyCalculator(IBeatmap beatmap) : base(beatmap)
+        public CatchDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+            : base(ruleset, beatmap)
         {
         }
 
-        public override double Calculate(Dictionary<string, double> categoryDifficulty = null) => 0;
+        protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate) => new DifficultyAttributes(mods, 0);
     }
 }

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableCatchHitObject.cs

@@ -42,6 +42,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
     {
         public virtual bool CanBePlated => false;
 
+        public virtual bool StaysOnPlate => CanBePlated;
+
         protected DrawableCatchHitObject(CatchHitObject hitObject)
             : base(hitObject)
         {

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableDroplet.cs

@@ -13,6 +13,8 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
     {
         private Pulp pulp;
 
+        public override bool StaysOnPlate => false;
+
         public DrawableDroplet(Droplet h)
             : base(h)
         {

osu.Game.Rulesets.Catch/Objects/JuiceStream.cs

@@ -124,6 +124,9 @@ namespace osu.Game.Rulesets.Catch.Objects
                     X = X + Curve.PositionAt(reversed ? 0 : 1).X / CatchPlayfield.BASE_WIDTH
                 });
             }
+
+            if (NestedHitObjects.LastOrDefault() is IHasComboInformation lastNested)
+                lastNested.LastInCombo = LastInCombo;
         }
 
         public double EndTime => StartTime + this.SpanCount() * Curve.Distance / Velocity;

osu.Game.Rulesets.Catch/UI/CatcherArea.cs

@@ -48,6 +48,16 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public void OnJudgement(DrawableCatchHitObject fruit, Judgement judgement)
         {
+            void runAfterLoaded(Action action)
+            {
+                // this is required to make this run after the last caught fruit runs UpdateState at least once.
+                // TODO: find a better alternative
+                if (lastPlateableFruit.IsLoaded)
+                    action();
+                else
+                    lastPlateableFruit.OnLoadComplete = _ => action();
+            }
+
             if (judgement.IsHit && fruit.CanBePlated)
             {
                 var caughtFruit = (DrawableCatchHitObject)GetVisualRepresentation?.Invoke(fruit.HitObject);
@@ -63,21 +73,17 @@ namespace osu.Game.Rulesets.Catch.UI
                 caughtFruit.LifetimeEnd = double.MaxValue;
 
                 MovableCatcher.Add(caughtFruit);
-
                 lastPlateableFruit = caughtFruit;
+
+                if (!fruit.StaysOnPlate)
+                    runAfterLoaded(() => MovableCatcher.Explode(caughtFruit));
+
             }
 
             if (fruit.HitObject.LastInCombo)
             {
                 if (judgement.IsHit)
-                {
-                    // this is required to make this run after the last caught fruit runs UpdateState at least once.
-                    // TODO: find a better alternative
-                    if (lastPlateableFruit.IsLoaded)
-                        MovableCatcher.Explode();
-                    else
-                        lastPlateableFruit.OnLoadComplete = _ => { MovableCatcher.Explode(); };
-                }
+                    runAfterLoaded(() => MovableCatcher.Explode());
                 else
                     MovableCatcher.Drop();
             }
@@ -378,28 +384,31 @@ namespace osu.Game.Rulesets.Catch.UI
                 var fruit = caughtFruit.ToArray();
 
                 foreach (var f in fruit)
+                    Explode(f);
+            }
+
+            public void Explode(DrawableHitObject fruit)
+            {
+                var originalX = fruit.X * Scale.X;
+
+                if (ExplodingFruitTarget != null)
                 {
-                    var originalX = f.X * Scale.X;
+                    fruit.Anchor = Anchor.TopLeft;
+                    fruit.Position = caughtFruit.ToSpaceOfOtherDrawable(fruit.DrawPosition, ExplodingFruitTarget);
 
-                    if (ExplodingFruitTarget != null)
-                    {
-                        f.Anchor = Anchor.TopLeft;
-                        f.Position = caughtFruit.ToSpaceOfOtherDrawable(f.DrawPosition, ExplodingFruitTarget);
+                    caughtFruit.Remove(fruit);
 
-                        caughtFruit.Remove(f);
-
-                        ExplodingFruitTarget.Add(f);
-                    }
-
-                    f.MoveToY(f.Y - 50, 250, Easing.OutSine)
-                     .Then()
-                     .MoveToY(f.Y + 50, 500, Easing.InSine);
-
-                    f.MoveToX(f.X + originalX * 6, 1000);
-                    f.FadeOut(750);
-
-                    f.Expire();
+                    ExplodingFruitTarget.Add(fruit);
                 }
+
+                fruit.MoveToY(fruit.Y - 50, 250, Easing.OutSine)
+                 .Then()
+                 .MoveToY(fruit.Y + 50, 500, Easing.InSine);
+
+                fruit.MoveToX(fruit.X + originalX * 6, 1000);
+                fruit.FadeOut(750);
+
+                fruit.Expire();
             }
 
             private class CatcherSprite : Sprite

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

@@ -1,16 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    [TestFixture]
-    public class TestCasePerformancePoints : Game.Tests.Visual.TestCasePerformancePoints
-    {
-        public TestCasePerformancePoints()
-            : base(new ManiaRuleset())
-        {
-        }
-    }
-}

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs

@@ -58,6 +58,13 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
         public override Pattern Generate()
         {
+            if (TotalColumns == 1)
+            {
+                var pattern = new Pattern();
+                addToPattern(pattern, 0, HitObject.StartTime, endTime);
+                return pattern;
+            }
+
             if (spanCount > 1)
             {
                 if (segmentDuration <= 90)

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/HitObjectPatternGenerator.cs

@@ -77,10 +77,25 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             }
             else
                 convertType |= PatternType.LowProbability;
+
+            if ((convertType & PatternType.KeepSingle) == 0)
+            {
+                if (HitObject.Samples.Any(s => s.Name == SampleInfo.HIT_FINISH) && TotalColumns != 8)
+                    convertType |= PatternType.Mirror;
+                else
+                    convertType |= PatternType.Gathered;
+            }
         }
 
         public override Pattern Generate()
         {
+            if (TotalColumns == 1)
+            {
+                var pattern = new Pattern();
+                addToPattern(pattern, 0);
+                return pattern;
+            }
+
             int lastColumn = PreviousPattern.HitObjects.FirstOrDefault()?.Column ?? 0;
 
             if ((convertType & PatternType.Reverse) > 0 && PreviousPattern.HitObjects.Any())
@@ -346,7 +361,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             addToCentre = false;
 
             if ((convertType & PatternType.ForceNotStack) > 0)
-                return getRandomNoteCount(p2 / 2, p2, (p2 + p3) / 2, p3);
+                return getRandomNoteCount(1 / 2f + p2 / 2, p2, (p2 + p3) / 2, p3);
 
             switch (TotalColumns)
             {

osu.Game.Rulesets.Mania/Configuration/ManiaConfigManager.cs

@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
 {
     public class ManiaConfigManager : RulesetConfigManager<ManiaSetting>
     {
-        public ManiaConfigManager(SettingsStore settings, RulesetInfo ruleset, int variant)
+        public ManiaConfigManager(SettingsStore settings, RulesetInfo ruleset, int? variant = null)
             : base(settings, ruleset, variant)
         {
         }

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

@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 
@@ -28,47 +29,33 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         /// </summary>
         private const double decay_weight = 0.9;
 
-        /// <summary>
-        /// HitObjects are stored as a member variable.
-        /// </summary>
-        private readonly List<ManiaHitObjectDifficulty> difficultyHitObjects = new List<ManiaHitObjectDifficulty>();
-
-        public ManiaDifficultyCalculator(IBeatmap beatmap)
-            : base(beatmap)
+        public ManiaDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+            : base(ruleset, beatmap)
         {
         }
 
-        public ManiaDifficultyCalculator(IBeatmap beatmap, Mod[] mods)
-            : base(beatmap, mods)
+        protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate)
         {
-        }
+            var difficultyHitObjects = new List<ManiaHitObjectDifficulty>();
 
-        public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
-        {
-            // Fill our custom DifficultyHitObject class, that carries additional information
-            difficultyHitObjects.Clear();
-
-            int columnCount = (Beatmap as ManiaBeatmap)?.TotalColumns ?? 7;
+            int columnCount = ((ManiaBeatmap)beatmap).TotalColumns;
 
             // Sort DifficultyHitObjects by StartTime of the HitObjects - just to make sure.
             // Note: Stable sort is done so that the ordering of hitobjects with equal start times doesn't change
-            difficultyHitObjects.AddRange(Beatmap.HitObjects.Select(h => new ManiaHitObjectDifficulty((ManiaHitObject)h, columnCount)).OrderBy(h => h.BaseHitObject.StartTime));
+            difficultyHitObjects.AddRange(beatmap.HitObjects.Select(h => new ManiaHitObjectDifficulty((ManiaHitObject)h, columnCount)).OrderBy(h => h.BaseHitObject.StartTime));
 
-            if (!calculateStrainValues())
-                return 0;
+            if (!calculateStrainValues(difficultyHitObjects, timeRate))
+                return new DifficultyAttributes(mods, 0);
 
-            double starRating = calculateDifficulty() * star_scaling_factor;
+            double starRating = calculateDifficulty(difficultyHitObjects, timeRate) * star_scaling_factor;
 
-            if (categoryDifficulty != null)
-                categoryDifficulty["Strain"] = starRating;
-
-            return starRating;
+            return new DifficultyAttributes(mods, starRating);
         }
 
-        private bool calculateStrainValues()
+        private bool calculateStrainValues(List<ManiaHitObjectDifficulty> objects, double timeRate)
         {
             // Traverse hitObjects in pairs to calculate the strain value of NextHitObject from the strain value of CurrentHitObject and environment.
-            using (List<ManiaHitObjectDifficulty>.Enumerator hitObjectsEnumerator = difficultyHitObjects.GetEnumerator())
+            using (var hitObjectsEnumerator = objects.GetEnumerator())
             {
                 if (!hitObjectsEnumerator.MoveNext())
                     return false;
@@ -79,7 +66,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
                 while (hitObjectsEnumerator.MoveNext())
                 {
                     var next = hitObjectsEnumerator.Current;
-                    next?.CalculateStrains(current, TimeRate);
+                    next?.CalculateStrains(current, timeRate);
                     current = next;
                 }
 
@@ -87,9 +74,9 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             }
         }
 
-        private double calculateDifficulty()
+        private double calculateDifficulty(List<ManiaHitObjectDifficulty> objects, double timeRate)
         {
-            double actualStrainStep = strain_step * TimeRate;
+            double actualStrainStep = strain_step * timeRate;
 
             // Find the highest strain value within each strain step
             List<double> highestStrains = new List<double>();
@@ -97,7 +84,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
             double maximumStrain = 0; // We need to keep track of the maximum strain in the current interval
 
             ManiaHitObjectDifficulty previousHitObject = null;
-            foreach (var hitObject in difficultyHitObjects)
+            foreach (var hitObject in objects)
             {
                 // While we are beyond the current interval push the currently available maximum to our strain list
                 while (hitObject.BaseHitObject.StartTime > intervalEndTime)
@@ -141,5 +128,23 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
             return difficulty;
         }
+
+        protected override Mod[] DifficultyAdjustmentMods => new Mod[]
+        {
+            new ManiaModDoubleTime(),
+            new ManiaModHalfTime(),
+            new ManiaModEasy(),
+            new ManiaModHardRock(),
+            new ManiaModKey1(),
+            new ManiaModKey2(),
+            new ManiaModKey3(),
+            new ManiaModKey4(),
+            new ManiaModKey5(),
+            new ManiaModKey6(),
+            new ManiaModKey7(),
+            new ManiaModKey8(),
+            new ManiaModKey9(),
+        };
+
     }
 }

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

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         private int countMeh;
         private int countMiss;
 
-        public ManiaPerformanceCalculator(Ruleset ruleset, IBeatmap beatmap, Score score)
+        public ManiaPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, Score score)
             : base(ruleset, beatmap, score)
         {
         }
@@ -82,7 +82,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         private double computeStrainValue()
         {
             // Obtain strain difficulty
-            double strainValue = Math.Pow(5 * Math.Max(1, Attributes["Strain"] / 0.2) - 4.0, 2.2) / 135.0;
+            double strainValue = Math.Pow(5 * Math.Max(1, Attributes.StarRating / 0.2) - 4.0, 2.2) / 135.0;
 
             // Longer maps are worth more
             strainValue *= 1.0 + 0.1 * Math.Min(1.0, totalHits / 1500.0);

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -15,8 +15,11 @@ using osu.Game.Graphics;
 using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Beatmaps.Legacy;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Difficulty;
 using osu.Game.Rulesets.Scoring;
 
@@ -26,7 +29,7 @@ namespace osu.Game.Rulesets.Mania
     {
         public override RulesetContainer CreateRulesetContainerWith(WorkingBeatmap beatmap) => new ManiaRulesetContainer(this, beatmap);
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new ManiaBeatmapConverter(beatmap);
-        public override PerformanceCalculator CreatePerformanceCalculator(IBeatmap beatmap, Score score) => new ManiaPerformanceCalculator(this, beatmap, score);
+        public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, Score score) => new ManiaPerformanceCalculator(this, beatmap, score);
 
         public override IEnumerable<Mod> ConvertLegacyMods(LegacyMods mods)
         {
@@ -105,78 +108,34 @@ namespace osu.Game.Rulesets.Mania
                     {
                         new ManiaModEasy(),
                         new ManiaModNoFail(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new ManiaModHalfTime(),
-                                new ManiaModDaycore(),
-                            },
-                        },
+                        new MultiMod(new ManiaModHalfTime(), new ManiaModDaycore()),
                     };
-
                 case ModType.DifficultyIncrease:
                     return new Mod[]
                     {
                         new ManiaModHardRock(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new ManiaModSuddenDeath(),
-                                new ManiaModPerfect(),
-                            },
-                        },
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new ManiaModDoubleTime(),
-                                new ManiaModNightcore(),
-                            },
-                        },
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new ManiaModFadeIn(),
-                                new ManiaModHidden(),
-                            }
-                        },
+                        new MultiMod(new ManiaModSuddenDeath(), new ManiaModPerfect()),
+                        new MultiMod(new ManiaModDoubleTime(), new ManiaModNightcore()),
+                        new MultiMod(new ManiaModFadeIn(), new ManiaModHidden()),
                         new ManiaModFlashlight(),
                     };
-
                 case ModType.Special:
                     return new Mod[]
                     {
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new ManiaModKey4(),
-                                new ManiaModKey5(),
-                                new ManiaModKey6(),
-                                new ManiaModKey7(),
-                                new ManiaModKey8(),
-                                new ManiaModKey9(),
-                                new ManiaModKey1(),
-                                new ManiaModKey2(),
-                                new ManiaModKey3(),
-                            },
-                        },
+                        new MultiMod(new ManiaModKey4(),
+                            new ManiaModKey5(),
+                            new ManiaModKey6(),
+                            new ManiaModKey7(),
+                            new ManiaModKey8(),
+                            new ManiaModKey9(),
+                            new ManiaModKey1(),
+                            new ManiaModKey2(),
+                            new ManiaModKey3()),
                         new ManiaModRandom(),
                         new ManiaModDualStages(),
                         new ManiaModMirror(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new ManiaModAutoplay(),
-                                new ModCinema(),
-                            },
-                        },
+                        new MultiMod(new ManiaModAutoplay(), new ModCinema()),
                     };
-
                 default:
                     return new Mod[] { };
             }
@@ -188,12 +147,14 @@ namespace osu.Game.Rulesets.Mania
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_mania_o };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(IBeatmap beatmap, Mod[] mods = null) => new ManiaDifficultyCalculator(beatmap, mods);
+        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new ManiaDifficultyCalculator(this, beatmap);
 
         public override int? LegacyID => 3;
 
         public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new ManiaReplayFrame();
 
+        public override IRulesetConfigManager CreateConfig(SettingsStore settings) => new ManiaConfigManager(settings, RulesetInfo);
+
         public ManiaRuleset(RulesetInfo rulesetInfo = null)
             : base(rulesetInfo)
         {

osu.Game.Rulesets.Mania/Mods/ManiaKeyMod.cs

@@ -1,6 +1,8 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mods;
@@ -24,5 +26,18 @@ namespace osu.Game.Rulesets.Mania.Mods
 
             mbc.TargetColumns = KeyCount;
         }
+
+        public override Type[] IncompatibleMods => new[]
+        {
+            typeof(ManiaModKey1),
+            typeof(ManiaModKey2),
+            typeof(ManiaModKey3),
+            typeof(ManiaModKey4),
+            typeof(ManiaModKey5),
+            typeof(ManiaModKey6),
+            typeof(ManiaModKey7),
+            typeof(ManiaModKey8),
+            typeof(ManiaModKey9),
+        }.Except(new[] { GetType() }).ToArray();
     }
 }

osu.Game.Rulesets.Mania/UI/Column.cs

@@ -277,8 +277,13 @@ namespace osu.Game.Rulesets.Mania.UI
             if (action != Action)
                 return false;
 
-            var hitObject = HitObjects.Objects.LastOrDefault(h => h.HitObject.StartTime > Time.Current) ?? HitObjects.Objects.FirstOrDefault();
-            hitObject?.PlaySamples();
+            var nextObject =
+                HitObjects.AliveObjects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
+                // fallback to non-alive objects to find next off-screen object
+                HitObjects.Objects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
+                HitObjects.Objects.LastOrDefault();
+
+            nextObject?.PlaySamples();
 
             return true;
         }

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

@@ -15,6 +15,8 @@ namespace osu.Game.Rulesets.Mania.UI
 {
     internal class HitExplosion : CompositeDrawable
     {
+        public override bool RemoveWhenNotAlive => true;
+
         private readonly CircularContainer circle;
 
         public HitExplosion(DrawableHitObject judgedObject)

osu.Game.Rulesets.Mania/UI/ManiaRulesetContainer.cs

@@ -10,12 +10,9 @@ using osu.Framework.Input;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
-using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Mods;
-using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Replays;
@@ -103,7 +100,5 @@ namespace osu.Game.Rulesets.Mania.UI
         protected override Vector2 PlayfieldArea => new Vector2(1, 0.8f);
 
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new ManiaFramedReplayInputHandler(replay);
-
-        protected override IRulesetConfigManager CreateConfig(Ruleset ruleset, SettingsStore settings) => new ManiaConfigManager(settings, Ruleset.RulesetInfo, Variant);
     }
 }

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

@@ -1,16 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-
-namespace osu.Game.Rulesets.Osu.Tests
-{
-    [TestFixture]
-    public class TestCasePerformancePoints : Game.Tests.Visual.TestCasePerformancePoints
-    {
-        public TestCasePerformancePoints()
-            : base(new OsuRuleset())
-        {
-        }
-    }
-}

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

@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Rulesets.Osu.Difficulty
+{
+    public class OsuDifficultyAttributes : DifficultyAttributes
+    {
+        public double AimStrain;
+        public double SpeedStrain;
+
+        public OsuDifficultyAttributes(Mod[] mods, double starRating)
+            : base(mods, starRating)
+        {
+        }
+    }
+}

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

@@ -2,12 +2,13 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Difficulty.Skills;
+using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Difficulty
@@ -17,31 +18,26 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         private const int section_length = 400;
         private const double difficulty_multiplier = 0.0675;
 
-        public OsuDifficultyCalculator(IBeatmap beatmap)
-            : base(beatmap)
+        public OsuDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+            : base(ruleset, beatmap)
         {
         }
 
-        public OsuDifficultyCalculator(IBeatmap beatmap, Mod[] mods)
-            : base(beatmap, mods)
+        protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate)
         {
-        }
-
-        public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
-        {
-            OsuDifficultyBeatmap beatmap = new OsuDifficultyBeatmap((List<OsuHitObject>)Beatmap.HitObjects, TimeRate);
+            OsuDifficultyBeatmap difficultyBeatmap = new OsuDifficultyBeatmap(beatmap.HitObjects.Cast<OsuHitObject>().ToList(), timeRate);
             Skill[] skills =
             {
                 new Aim(),
                 new Speed()
             };
 
-            double sectionLength = section_length * TimeRate;
+            double sectionLength = section_length * timeRate;
 
             // The first object doesn't generate a strain, so we begin with an incremented section end
             double currentSectionEnd = 2 * sectionLength;
 
-            foreach (OsuDifficultyHitObject h in beatmap)
+            foreach (OsuDifficultyHitObject h in difficultyBeatmap)
             {
                 while (h.BaseObject.StartTime > currentSectionEnd)
                 {
@@ -60,16 +56,21 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
             double aimRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier;
             double speedRating = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier;
-
             double starRating = aimRating + speedRating + Math.Abs(aimRating - speedRating) / 2;
 
-            if (categoryDifficulty != null)
+            return new OsuDifficultyAttributes(mods, starRating)
             {
-                categoryDifficulty.Add("Aim", aimRating);
-                categoryDifficulty.Add("Speed", speedRating);
-            }
-
-            return starRating;
+                AimStrain = aimRating,
+                SpeedStrain = speedRating
+            };
         }
+
+        protected override Mod[] DifficultyAdjustmentMods => new Mod[]
+        {
+            new OsuModDoubleTime(),
+            new OsuModHalfTime(),
+            new OsuModEasy(),
+            new OsuModHardRock(),
+        };
     }
 }

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

@@ -15,6 +15,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 {
     public class OsuPerformanceCalculator : PerformanceCalculator
     {
+        public new OsuDifficultyAttributes Attributes => (OsuDifficultyAttributes)base.Attributes;
+
         private readonly int countHitCircles;
         private readonly int beatmapMaxCombo;
 
@@ -37,7 +39,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         private int countMeh;
         private int countMiss;
 
-        public OsuPerformanceCalculator(Ruleset ruleset, IBeatmap beatmap, Score score)
+        public OsuPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, Score score)
             : base(ruleset, beatmap, score)
         {
             countHitCircles = Beatmap.HitObjects.Count(h => h is HitCircle);
@@ -102,7 +104,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
         private double computeAimValue()
         {
-            double aimValue = Math.Pow(5.0f * Math.Max(1.0f, Attributes["Aim"] / 0.0675f) - 4.0f, 3.0f) / 100000.0f;
+            double aimValue = Math.Pow(5.0f * Math.Max(1.0f, Attributes.AimStrain / 0.0675f) - 4.0f, 3.0f) / 100000.0f;
 
             // Longer maps are worth more
             double lengthBonus = 0.95f + 0.4f * Math.Min(1.0f, totalHits / 2000.0f) +
@@ -151,7 +153,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
 
         private double computeSpeedValue()
         {
-            double speedValue = Math.Pow(5.0f * Math.Max(1.0f, Attributes["Speed"] / 0.0675f) - 4.0f, 3.0f) / 100000.0f;
+            double speedValue = Math.Pow(5.0f * Math.Max(1.0f, Attributes.SpeedStrain / 0.0675f) - 4.0f, 3.0f) / 100000.0f;
 
             // Longer maps are worth more
             speedValue *= 0.95f + 0.4f * Math.Min(1.0f, totalHits / 2000.0f) +

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -93,57 +93,26 @@ namespace osu.Game.Rulesets.Osu
                     {
                         new OsuModEasy(),
                         new OsuModNoFail(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new OsuModHalfTime(),
-                                new OsuModDaycore(),
-                            },
-                        },
+                        new MultiMod(new OsuModHalfTime(), new OsuModDaycore()),
                     };
-
                 case ModType.DifficultyIncrease:
                     return new Mod[]
                     {
                         new OsuModHardRock(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new OsuModSuddenDeath(),
-                                new OsuModPerfect(),
-                            },
-                        },
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new OsuModDoubleTime(),
-                                new OsuModNightcore(),
-                            },
-                        },
+                        new MultiMod(new OsuModSuddenDeath(), new OsuModPerfect()),
+                        new MultiMod(new OsuModDoubleTime(), new OsuModNightcore()),
                         new OsuModHidden(),
                         new OsuModFlashlight(),
                     };
-
                 case ModType.Special:
                     return new Mod[]
                     {
                         new OsuModRelax(),
                         new OsuModAutopilot(),
                         new OsuModSpunOut(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new OsuModAutoplay(),
-                                new ModCinema(),
-                            },
-                        },
+                        new MultiMod(new OsuModAutoplay(), new ModCinema()),
                         new OsuModTarget(),
                     };
-
                 default:
                     return new Mod[] { };
             }
@@ -151,9 +120,9 @@ namespace osu.Game.Rulesets.Osu
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_osu_o };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(IBeatmap beatmap, Mod[] mods = null) => new OsuDifficultyCalculator(beatmap, mods);
+        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new OsuDifficultyCalculator(this, beatmap);
 
-        public override PerformanceCalculator CreatePerformanceCalculator(IBeatmap beatmap, Score score) => new OsuPerformanceCalculator(this, beatmap, score);
+        public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, Score score) => new OsuPerformanceCalculator(this, beatmap, score);
 
         public override HitObjectComposer CreateHitObjectComposer() => new OsuHitObjectComposer(this);
 
@@ -161,7 +130,7 @@ namespace osu.Game.Rulesets.Osu
 
         public override string ShortName => "osu";
 
-        public override SettingsSubsection CreateSettings() => new OsuSettings();
+        public override RulesetSettingsSubsection CreateSettings() => new OsuSettings(this);
 
         public override int? LegacyID => 0;
 

osu.Game.Rulesets.Osu/UI/Cursor/GameplayCursor.cs

@@ -161,7 +161,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 };
 
                 this.beatmap.BindTo(beatmap);
-                beatmap.ValueChanged += v => calculateScale();
+                this.beatmap.ValueChanged += v => calculateScale();
 
                 cursorScale = config.GetBindable<double>(OsuSetting.GameplayCursorSize);
                 cursorScale.ValueChanged += v => calculateScale();

osu.Game.Rulesets.Osu/UI/OsuPlayfield.cs

@@ -64,9 +64,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
         public override void PostProcess()
         {
-            connectionLayer.HitObjects = HitObjects.Objects
-                .Select(d => d.HitObject)
-                .OrderBy(h => h.StartTime).OfType<OsuHitObject>();
+            connectionLayer.HitObjects = HitObjects.Objects.Select(d => d.HitObject).OfType<OsuHitObject>();
         }
 
         private void onJudgement(DrawableHitObject judgedObject, Judgement judgement)

osu.Game.Rulesets.Osu/UI/OsuSettings.cs

@@ -8,10 +8,15 @@ using osu.Game.Overlays.Settings;
 
 namespace osu.Game.Rulesets.Osu.UI
 {
-    public class OsuSettings : SettingsSubsection
+    public class OsuSettings : RulesetSettingsSubsection
     {
         protected override string Header => "osu!";
 
+        public OsuSettings(Ruleset ruleset)
+            : base(ruleset)
+        {
+        }
+
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
         {

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

@@ -1,16 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using NUnit.Framework;
-
-namespace osu.Game.Rulesets.Taiko.Tests
-{
-    [TestFixture]
-    public class TestCasePerformancePoints : Game.Tests.Visual.TestCasePerformancePoints
-    {
-        public TestCasePerformancePoints()
-            : base(new TaikoRuleset())
-        {
-        }
-    }
-}

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

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Taiko.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty
@@ -26,46 +27,33 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         /// </summary>
         private const double decay_weight = 0.9;
 
-        /// <summary>
-        /// HitObjects are stored as a member variable.
-        /// </summary>
-        private readonly List<TaikoHitObjectDifficulty> difficultyHitObjects = new List<TaikoHitObjectDifficulty>();
-
-        public TaikoDifficultyCalculator(IBeatmap beatmap)
-            : base(beatmap)
+        public TaikoDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
+            : base(ruleset, beatmap)
         {
         }
 
-        public TaikoDifficultyCalculator(IBeatmap beatmap, Mod[] mods)
-            : base(beatmap, mods)
+        protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate)
         {
-        }
+            var difficultyHitObjects = new List<TaikoHitObjectDifficulty>();
 
-        public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
-        {
-            // Fill our custom DifficultyHitObject class, that carries additional information
-            difficultyHitObjects.Clear();
-
-            foreach (var hitObject in Beatmap.HitObjects)
+            foreach (var hitObject in beatmap.HitObjects)
                 difficultyHitObjects.Add(new TaikoHitObjectDifficulty((TaikoHitObject)hitObject));
 
             // Sort DifficultyHitObjects by StartTime of the HitObjects - just to make sure.
             difficultyHitObjects.Sort((a, b) => a.BaseHitObject.StartTime.CompareTo(b.BaseHitObject.StartTime));
 
-            if (!calculateStrainValues()) return 0;
+            if (!calculateStrainValues(difficultyHitObjects, timeRate))
+                return new DifficultyAttributes(mods, 0);
 
-            double starRating = calculateDifficulty() * star_scaling_factor;
+            double starRating = calculateDifficulty(difficultyHitObjects, timeRate) * star_scaling_factor;
 
-            if (categoryDifficulty != null)
-                categoryDifficulty["Strain"] = starRating;
-
-            return starRating;
+            return new DifficultyAttributes(mods, starRating);
         }
 
-        private bool calculateStrainValues()
+        private bool calculateStrainValues(List<TaikoHitObjectDifficulty> objects, double timeRate)
         {
             // Traverse hitObjects in pairs to calculate the strain value of NextHitObject from the strain value of CurrentHitObject and environment.
-            using (List<TaikoHitObjectDifficulty>.Enumerator hitObjectsEnumerator = difficultyHitObjects.GetEnumerator())
+            using (var hitObjectsEnumerator = objects.GetEnumerator())
             {
                 if (!hitObjectsEnumerator.MoveNext()) return false;
 
@@ -75,7 +63,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                 while (hitObjectsEnumerator.MoveNext())
                 {
                     var next = hitObjectsEnumerator.Current;
-                    next?.CalculateStrains(current, TimeRate);
+                    next?.CalculateStrains(current, timeRate);
                     current = next;
                 }
 
@@ -83,9 +71,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             }
         }
 
-        private double calculateDifficulty()
+        private double calculateDifficulty(List<TaikoHitObjectDifficulty> objects, double timeRate)
         {
-            double actualStrainStep = strain_step * TimeRate;
+            double actualStrainStep = strain_step * timeRate;
 
             // Find the highest strain value within each strain step
             List<double> highestStrains = new List<double>();
@@ -93,7 +81,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
             double maximumStrain = 0; // We need to keep track of the maximum strain in the current interval
 
             TaikoHitObjectDifficulty previousHitObject = null;
-            foreach (var hitObject in difficultyHitObjects)
+            foreach (var hitObject in objects)
             {
                 // While we are beyond the current interval push the currently available maximum to our strain list
                 while (hitObject.BaseHitObject.StartTime > intervalEndTime)
@@ -135,5 +123,13 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
             return difficulty;
         }
+
+        protected override Mod[] DifficultyAdjustmentMods => new Mod[]
+        {
+            new TaikoModDoubleTime(),
+            new TaikoModHalfTime(),
+            new TaikoModEasy(),
+            new TaikoModHardRock(),
+        };
     }
 }

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

@@ -22,10 +22,10 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
         private int countMeh;
         private int countMiss;
 
-        public TaikoPerformanceCalculator(Ruleset ruleset, IBeatmap beatmap, Score score)
+        public TaikoPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, Score score)
             : base(ruleset, beatmap, score)
         {
-            beatmapMaxCombo = beatmap.HitObjects.Count(h => h is Hit);
+            beatmapMaxCombo = Beatmap.HitObjects.Count(h => h is Hit);
         }
 
         public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
@@ -68,7 +68,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
 
         private double computeStrainValue()
         {
-            double strainValue = Math.Pow(5.0 * Math.Max(1.0, Attributes["Strain"] / 0.0075) - 4.0, 2.0) / 100000.0;
+            double strainValue = Math.Pow(5.0 * Math.Max(1.0, Attributes.StarRating / 0.0075) - 4.0, 2.0) / 100000.0;
 
             // Longer maps are worth more
             double lengthBonus = 1 + 0.1f * Math.Min(1.0, totalHits / 1500.0);

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -84,56 +84,25 @@ namespace osu.Game.Rulesets.Taiko
                     {
                         new TaikoModEasy(),
                         new TaikoModNoFail(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new TaikoModHalfTime(),
-                                new TaikoModDaycore(),
-                            },
-                        },
+                        new MultiMod(new TaikoModHalfTime(), new TaikoModDaycore()),
                     };
-
                 case ModType.DifficultyIncrease:
                     return new Mod[]
                     {
                         new TaikoModHardRock(),
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new TaikoModSuddenDeath(),
-                                new TaikoModPerfect(),
-                            },
-                        },
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new TaikoModDoubleTime(),
-                                new TaikoModNightcore(),
-                            },
-                        },
+                        new MultiMod(new TaikoModSuddenDeath(), new TaikoModPerfect()),
+                        new MultiMod(new TaikoModDoubleTime(), new TaikoModNightcore()),
                         new TaikoModHidden(),
                         new TaikoModFlashlight(),
                     };
-
                 case ModType.Special:
                     return new Mod[]
                     {
                         new TaikoModRelax(),
                         null,
                         null,
-                        new MultiMod
-                        {
-                            Mods = new Mod[]
-                            {
-                                new TaikoModAutoplay(),
-                                new ModCinema(),
-                            },
-                        },
+                        new MultiMod(new TaikoModAutoplay(), new ModCinema()),
                     };
-
                 default:
                     return new Mod[] { };
             }
@@ -145,9 +114,9 @@ namespace osu.Game.Rulesets.Taiko
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_taiko_o };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(IBeatmap beatmap, Mod[] mods = null) => new TaikoDifficultyCalculator(beatmap, mods);
+        public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new TaikoDifficultyCalculator(this, beatmap);
 
-        public override PerformanceCalculator CreatePerformanceCalculator(IBeatmap beatmap, Score score) => new TaikoPerformanceCalculator(this, beatmap, score);
+        public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, Score score) => new TaikoPerformanceCalculator(this, beatmap, score);
 
         public override int? LegacyID => 1;
 

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

@@ -18,6 +18,8 @@ namespace osu.Game.Rulesets.Taiko.UI
     /// </summary>
     internal class HitExplosion : CircularContainer
     {
+        public override bool RemoveWhenNotAlive => true;
+
         public readonly DrawableHitObject JudgedObject;
 
         private readonly Box innerFill;
@@ -66,7 +68,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             this.ScaleTo(3f, 1000, Easing.OutQuint);
             this.FadeOut(500);
 
-            Expire();
+            Expire(true);
         }
 
         /// <summary>

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

@@ -14,6 +14,8 @@ namespace osu.Game.Rulesets.Taiko.UI
 {
     public class KiaiHitExplosion : CircularContainer
     {
+        public override bool RemoveWhenNotAlive => true;
+
         public readonly DrawableHitObject JudgedObject;
 
         private readonly bool isRim;
@@ -62,7 +64,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             this.ScaleTo(new Vector2(1, 3f), 500, Easing.OutQuint);
             this.FadeOut(250);
 
-            Expire();
+            Expire(true);
         }
     }
 }

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs

@@ -86,7 +86,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.AreEqual(string.Empty, metadata.Source);
                 Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", metadata.Tags);
                 Assert.AreEqual(557821, beatmapInfo.OnlineBeatmapID);
-                Assert.AreEqual(241526, metadata.OnlineBeatmapSetID);
+                Assert.AreEqual(241526, beatmapInfo.BeatmapSet.OnlineBeatmapSetID);
             }
         }
 

osu.Game.Tests/Beatmaps/Formats/OsuJsonDecoderTest.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
         {
             var beatmap = decodeAsJson(normal);
             var meta = beatmap.BeatmapInfo.Metadata;
-            Assert.AreEqual(241526, meta.OnlineBeatmapSetID);
+            Assert.AreEqual(241526, beatmap.BeatmapInfo.BeatmapSet.OnlineBeatmapSetID);
             Assert.AreEqual("Soleily", meta.Artist);
             Assert.AreEqual("Soleily", meta.ArtistUnicode);
             Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);

osu.Game.Tests/Beatmaps/IO/OszArchiveReaderTest.cs

@@ -48,11 +48,14 @@ namespace osu.Game.Tests.Beatmaps.IO
             {
                 var reader = new ZipArchiveReader(osz);
 
-                BeatmapMetadata meta;
-                using (var stream = new StreamReader(reader.GetStream("Soleily - Renatus (Deif) [Platter].osu")))
-                    meta = Decoder.GetDecoder<Beatmap>(stream).Decode(stream).Metadata;
+                Beatmap beatmap;
 
-                Assert.AreEqual(241526, meta.OnlineBeatmapSetID);
+                using (var stream = new StreamReader(reader.GetStream("Soleily - Renatus (Deif) [Platter].osu")))
+                    beatmap = Decoder.GetDecoder<Beatmap>(stream).Decode(stream);
+
+                var meta = beatmap.Metadata;
+
+                Assert.AreEqual(241526, beatmap.BeatmapInfo.BeatmapSet.OnlineBeatmapSetID);
                 Assert.AreEqual("Soleily", meta.Artist);
                 Assert.AreEqual("Soleily", meta.ArtistUnicode);
                 Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);

osu.Game.Tests/NonVisual/DifficultyAdjustmentModCombinationsTest.cs

@@ -0,0 +1,152 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Difficulty;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [TestFixture]
+    public class DifficultyAdjustmentModCombinationsTest
+    {
+        [Test]
+        public void TestNoMods()
+        {
+            var combinations = new TestDifficultyCalculator().CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(1, combinations.Length);
+            Assert.IsTrue(combinations[0] is NoModMod);
+        }
+
+        [Test]
+        public void TestSingleMod()
+        {
+            var combinations = new TestDifficultyCalculator(new ModA()).CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(2, combinations.Length);
+            Assert.IsTrue(combinations[0] is NoModMod);
+            Assert.IsTrue(combinations[1] is ModA);
+        }
+
+        [Test]
+        public void TestDoubleMod()
+        {
+            var combinations = new TestDifficultyCalculator(new ModA(), new ModB()).CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(4, combinations.Length);
+            Assert.IsTrue(combinations[0] is NoModMod);
+            Assert.IsTrue(combinations[1] is ModA);
+            Assert.IsTrue(combinations[2] is MultiMod);
+            Assert.IsTrue(combinations[3] is ModB);
+
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModA);
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModB);
+        }
+
+        [Test]
+        public void TestIncompatibleMods()
+        {
+            var combinations = new TestDifficultyCalculator(new ModA(), new ModIncompatibleWithA()).CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(3, combinations.Length);
+            Assert.IsTrue(combinations[0] is NoModMod);
+            Assert.IsTrue(combinations[1] is ModA);
+            Assert.IsTrue(combinations[2] is ModIncompatibleWithA);
+        }
+
+        [Test]
+        public void TestDoubleIncompatibleMods()
+        {
+            var combinations = new TestDifficultyCalculator(new ModA(), new ModB(), new ModIncompatibleWithA(), new ModIncompatibleWithAAndB()).CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(8, combinations.Length);
+            Assert.IsTrue(combinations[0] is NoModMod);
+            Assert.IsTrue(combinations[1] is ModA);
+            Assert.IsTrue(combinations[2] is MultiMod);
+            Assert.IsTrue(combinations[3] is ModB);
+            Assert.IsTrue(combinations[4] is MultiMod);
+            Assert.IsTrue(combinations[5] is ModIncompatibleWithA);
+            Assert.IsTrue(combinations[6] is MultiMod);
+            Assert.IsTrue(combinations[7] is ModIncompatibleWithAAndB);
+
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[0] is ModA);
+            Assert.IsTrue(((MultiMod)combinations[2]).Mods[1] is ModB);
+            Assert.IsTrue(((MultiMod)combinations[4]).Mods[0] is ModB);
+            Assert.IsTrue(((MultiMod)combinations[4]).Mods[1] is ModIncompatibleWithA);
+            Assert.IsTrue(((MultiMod)combinations[6]).Mods[0] is ModIncompatibleWithA);
+            Assert.IsTrue(((MultiMod)combinations[6]).Mods[1] is ModIncompatibleWithAAndB);
+        }
+
+        [Test]
+        public void TestIncompatibleThroughBaseType()
+        {
+            var combinations = new TestDifficultyCalculator(new ModAofA(), new ModIncompatibleWithAofA()).CreateDifficultyAdjustmentModCombinations();
+
+            Assert.AreEqual(3, combinations.Length);
+            Assert.IsTrue(combinations[0] is NoModMod);
+            Assert.IsTrue(combinations[1] is ModAofA);
+            Assert.IsTrue(combinations[2] is ModIncompatibleWithAofA);
+        }
+
+        private class ModA : Mod
+        {
+            public override string Name => nameof(ModA);
+            public override string ShortenedName => nameof(ModA);
+            public override double ScoreMultiplier => 1;
+
+            public override Type[] IncompatibleMods => new[] { typeof(ModIncompatibleWithA), typeof(ModIncompatibleWithAAndB) };
+        }
+
+        private class ModB : Mod
+        {
+            public override string Name => nameof(ModB);
+            public override string ShortenedName => nameof(ModB);
+            public override double ScoreMultiplier => 1;
+
+            public override Type[] IncompatibleMods => new[] { typeof(ModIncompatibleWithAAndB) };
+        }
+
+        private class ModIncompatibleWithA : Mod
+        {
+            public override string Name => $"Incompatible With {nameof(ModA)}";
+            public override string ShortenedName => $"Incompatible With {nameof(ModA)}";
+            public override double ScoreMultiplier => 1;
+
+            public override Type[] IncompatibleMods => new[] { typeof(ModA) };
+        }
+
+        private class ModAofA : ModA
+        {
+        }
+
+        private class ModIncompatibleWithAofA : ModIncompatibleWithA
+        {
+            // Incompatible through base type
+        }
+
+        private class ModIncompatibleWithAAndB : Mod
+        {
+            public override string Name => $"Incompatible With {nameof(ModA)} and {nameof(ModB)}";
+            public override string ShortenedName => $"Incompatible With {nameof(ModA)} and {nameof(ModB)}";
+            public override double ScoreMultiplier => 1;
+
+            public override Type[] IncompatibleMods => new[] { typeof(ModA), typeof(ModB) };
+        }
+
+        private class TestDifficultyCalculator : DifficultyCalculator
+        {
+            public TestDifficultyCalculator(params Mod[] mods)
+                : base(null, null)
+            {
+                DifficultyAdjustmentMods = mods;
+            }
+
+            protected override Mod[] DifficultyAdjustmentMods { get; }
+
+            protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate) => throw new NotImplementedException();
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseBeatmapCarousel.cs

@@ -449,7 +449,6 @@ namespace osu.Game.Tests.Visual
                 Hash = new MemoryStream(Encoding.UTF8.GetBytes(Guid.NewGuid().ToString())).ComputeMD5Hash(),
                 Metadata = new BeatmapMetadata
                 {
-                    OnlineBeatmapSetID = id,
                     // Create random metadata, then we can check if sorting works based on these
                     Artist = $"peppy{id.ToString().PadLeft(6, '0')}",
                     Title = $"test set #{id}!",
@@ -503,7 +502,6 @@ namespace osu.Game.Tests.Visual
                 Hash = new MemoryStream(Encoding.UTF8.GetBytes(Guid.NewGuid().ToString())).ComputeMD5Hash(),
                 Metadata = new BeatmapMetadata
                 {
-                    OnlineBeatmapSetID = id,
                     // Create random metadata, then we can check if sorting works based on these
                     Artist = $"peppy{id.ToString().PadLeft(6, '0')}",
                     Title = $"test set #{id}!",

osu.Game.Tests/Visual/TestCaseBeatmapScoresContainer.cs

@@ -6,7 +6,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
 using osu.Game.Graphics;
-using osu.Game.Online.API.Requests;
 using osu.Game.Overlays.BeatmapSet.Scores;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
@@ -15,6 +14,7 @@ using osu.Game.Users;
 using System.Collections.Generic;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Rulesets.Osu;
 
 namespace osu.Game.Tests.Visual
@@ -22,9 +22,9 @@ namespace osu.Game.Tests.Visual
     [System.ComponentModel.Description("in BeatmapOverlay")]
     public class TestCaseBeatmapScoresContainer : OsuTestCase
     {
-        private readonly IEnumerable<OnlineScore> scores;
-        private readonly IEnumerable<OnlineScore> anotherScores;
-        private readonly OnlineScore topScore;
+        private readonly IEnumerable<APIScore> scores;
+        private readonly IEnumerable<APIScore> anotherScores;
+        private readonly APIScore topScore;
         private readonly Box background;
 
         public TestCaseBeatmapScoresContainer()
@@ -52,12 +52,12 @@ namespace osu.Game.Tests.Visual
             AddStep("remove scores", () => scoresContainer.Scores = null);
             AddStep("resize to big", () => container.ResizeWidthTo(1, 300));
             AddStep("resize to normal", () => container.ResizeWidthTo(0.8f, 300));
-            AddStep("online scores", () => scoresContainer.Beatmap = new BeatmapInfo { OnlineBeatmapSetID = 1, OnlineBeatmapID = 75, Ruleset = new OsuRuleset().RulesetInfo });
+            AddStep("online scores", () => scoresContainer.Beatmap = new BeatmapInfo { OnlineBeatmapID = 75, Ruleset = new OsuRuleset().RulesetInfo });
 
 
             scores = new[]
             {
-                new OnlineScore
+                new APIScore
                 {
                     User = new User
                     {
@@ -80,7 +80,7 @@ namespace osu.Game.Tests.Visual
                     TotalScore = 1234567890,
                     Accuracy = 1,
                 },
-                new OnlineScore
+                new APIScore
                 {
                     User = new User
                     {
@@ -102,7 +102,7 @@ namespace osu.Game.Tests.Visual
                     TotalScore = 1234789,
                     Accuracy = 0.9997,
                 },
-                new OnlineScore
+                new APIScore
                 {
                     User = new User
                     {
@@ -123,7 +123,7 @@ namespace osu.Game.Tests.Visual
                     TotalScore = 12345678,
                     Accuracy = 0.9854,
                 },
-                new OnlineScore
+                new APIScore
                 {
                     User = new User
                     {
@@ -143,7 +143,7 @@ namespace osu.Game.Tests.Visual
                     TotalScore = 1234567,
                     Accuracy = 0.8765,
                 },
-                new OnlineScore
+                new APIScore
                 {
                     User = new User
                     {
@@ -169,7 +169,7 @@ namespace osu.Game.Tests.Visual
 
             anotherScores = new[]
             {
-                new OnlineScore
+                new APIScore
                 {
                     User = new User
                     {
@@ -191,7 +191,7 @@ namespace osu.Game.Tests.Visual
                     TotalScore = 1234789,
                     Accuracy = 0.9997,
                 },
-                new OnlineScore
+                new APIScore
                 {
                     User = new User
                     {
@@ -214,7 +214,7 @@ namespace osu.Game.Tests.Visual
                     TotalScore = 1234567890,
                     Accuracy = 1,
                 },
-                new OnlineScore
+                new APIScore
                 {
                     User = new User
                     {
@@ -230,7 +230,7 @@ namespace osu.Game.Tests.Visual
                     TotalScore = 123456,
                     Accuracy = 0.6543,
                 },
-                new OnlineScore
+                new APIScore
                 {
                     User = new User
                     {
@@ -251,7 +251,7 @@ namespace osu.Game.Tests.Visual
                     TotalScore = 12345678,
                     Accuracy = 0.9854,
                 },
-                new OnlineScore
+                new APIScore
                 {
                     User = new User
                     {
@@ -279,7 +279,7 @@ namespace osu.Game.Tests.Visual
                 s.Statistics.Add(HitResult.Meh, RNG.Next(2000));
             }
 
-            topScore = new OnlineScore
+            topScore = new APIScore
             {
                 User = new User
                 {

osu.Game.Tests/Visual/TestCaseEditorComposeTimeline.cs

@@ -15,7 +15,7 @@ namespace osu.Game.Tests.Visual
     [TestFixture]
     public class TestCaseEditorComposeTimeline : OsuTestCase
     {
-        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(ScrollableTimeline), typeof(ScrollingTimelineContainer), typeof(BeatmapWaveformGraph), typeof(TimelineButton) };
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(TimelineArea), typeof(Timeline), typeof(TimelineButton) };
 
         public TestCaseEditorComposeTimeline()
         {
@@ -27,11 +27,12 @@ namespace osu.Game.Tests.Visual
                     Origin = Anchor.TopCentre,
                     State = Visibility.Visible
                 },
-                new ScrollableTimeline
+                new TimelineArea
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
-                    Size = new Vector2(1000, 100)
+                    RelativeSizeAxes = Axes.X,
+                    Size = new Vector2(0.8f, 100)
                 }
             };
         }

osu.Game.Tests/Visual/TestCasePlaySongSelect.cs

@@ -122,7 +122,6 @@ namespace osu.Game.Tests.Visual
                 Hash = new MemoryStream(Encoding.UTF8.GetBytes(Guid.NewGuid().ToString())).ComputeMD5Hash(),
                 Metadata = new BeatmapMetadata
                 {
-                    OnlineBeatmapSetID = 1234 + i,
                     // Create random metadata, then we can check if sorting works based on these
                     Artist = "MONACA " + RNG.Next(0, 9),
                     Title = "Black Song " + RNG.Next(0, 9),

osu.Game.Tests/Visual/TestCaseUserProfileRecentSection.cs

@@ -12,6 +12,7 @@ using osu.Game.Overlays.Profile.Sections.Recent;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Tests.Visual
 {
@@ -49,15 +50,15 @@ namespace osu.Game.Tests.Visual
             };
         }
 
-        private IEnumerable<RecentActivity> createDummyActivities()
+        private IEnumerable<APIRecentActivity> createDummyActivities()
         {
-            var dummyBeatmap = new RecentActivity.RecentActivityBeatmap
+            var dummyBeatmap = new APIRecentActivity.RecentActivityBeatmap
             {
                 Title = @"Dummy beatmap",
                 Url = "/b/1337",
             };
 
-            var dummyUser = new RecentActivity.RecentActivityUser
+            var dummyUser = new APIRecentActivity.RecentActivityUser
             {
                 Username = "DummyReborn",
                 Url = "/u/666",
@@ -66,61 +67,61 @@ namespace osu.Game.Tests.Visual
 
             return new[]
             {
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.Achievement,
-                    Achievement = new RecentActivity.RecentActivityAchievement
+                    Achievement = new APIRecentActivity.RecentActivityAchievement
                     {
                         Name = @"Feelin' It",
                         Slug = @"all-secret-feelinit",
                     },
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.BeatmapPlaycount,
                     Count = 1337,
                     Beatmap = dummyBeatmap,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.BeatmapsetApprove,
                     Approval = BeatmapApproval.Qualified,
                     Beatmapset = dummyBeatmap,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.BeatmapsetDelete,
                     Beatmapset = dummyBeatmap,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.BeatmapsetRevive,
                     Beatmapset = dummyBeatmap,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.BeatmapsetRevive,
                     Beatmapset = dummyBeatmap,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.BeatmapsetUpdate,
                     Beatmapset = dummyBeatmap,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.BeatmapsetUpload,
                     Beatmapset = dummyBeatmap,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.Rank,
@@ -128,29 +129,29 @@ namespace osu.Game.Tests.Visual
                     Mode = "osu!",
                     Beatmap = dummyBeatmap,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.RankLost,
                     Mode = "osu!",
                     Beatmap = dummyBeatmap,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.UsernameChange,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.UserSupportAgain,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.UserSupportFirst,
                 },
-                new RecentActivity
+                new APIRecentActivity
                 {
                     User = dummyUser,
                     Type = RecentActivityType.UserSupportGift,

osu.Game.Tests/Visual/TestCaseVolumePieces.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Game.Overlays.Volume;
+using OpenTK;
 using OpenTK.Graphics;
 
 namespace osu.Game.Tests.Visual
@@ -17,13 +18,21 @@ namespace osu.Game.Tests.Visual
         {
             VolumeMeter meter;
             MuteButton mute;
-            Add(meter = new VolumeMeter("MASTER", 125, Color4.Blue));
+            Add(meter = new VolumeMeter("MASTER", 125, Color4.Blue) { Position = new Vector2(10) });
+            AddSliderStep("master volume", 0, 10, 0, i => meter.Bindable.Value = i * 0.1);
+
+            Add(new VolumeMeter("BIG", 250, Color4.Red)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Position = new Vector2(10),
+            });
+
             Add(mute = new MuteButton
             {
                 Margin = new MarginPadding { Top = 200 }
             });
 
-            AddSliderStep("master volume", 0, 10, 0, i => meter.Bindable.Value = i * 0.1);
             AddToggleStep("mute", b => mute.Current.Value = b);
         }
     }

osu.Game.Tests/Visual/TestCaseWaveform.cs

@@ -6,11 +6,11 @@ using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Audio;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
-using osu.Game.Screens.Edit.Screens.Compose.Timeline;
 
 namespace osu.Game.Tests.Visual
 {
@@ -40,14 +40,13 @@ namespace osu.Game.Tests.Visual
 
             for (int i = 1; i <= 16; i *= 2)
             {
-                var newDisplay = new BeatmapWaveformGraph
+                var newDisplay = new WaveformGraph
                 {
                     RelativeSizeAxes = Axes.Both,
                     Resolution = 1f / i,
-                    Beatmap = Beatmap
                 };
 
-                Beatmap.ValueChanged += b => newDisplay.Beatmap = b;
+                Beatmap.ValueChanged += b => newDisplay.Waveform = b.Waveform;
 
                 flow.Add(new Container
                 {

osu.Game.Tests/Visual/TestCaseZoomableScrollContainer.cs

@@ -0,0 +1,142 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.MathUtils;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Cursor;
+using osu.Game.Screens.Edit.Screens.Compose.Timeline;
+using OpenTK;
+using OpenTK.Graphics;
+using OpenTK.Input;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseZoomableScrollContainer : ManualInputManagerTestCase
+    {
+        private readonly ZoomableScrollContainer scrollContainer;
+        private readonly Drawable innerBox;
+
+        public TestCaseZoomableScrollContainer()
+        {
+            Children = new Drawable[]
+            {
+                new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    Height = 250,
+                    Width = 0.75f,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = OsuColour.Gray(30)
+                        },
+                        scrollContainer = new ZoomableScrollContainer { RelativeSizeAxes = Axes.Both }
+                    }
+                },
+                new MenuCursor()
+            };
+
+            scrollContainer.Add(innerBox = new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Colour = ColourInfo.GradientHorizontal(new Color4(0.8f, 0.6f, 0.4f, 1f), new Color4(0.4f, 0.6f, 0.8f, 1f))
+            });
+        }
+
+        [Test]
+        public void TestZoom0()
+        {
+            reset();
+            AddAssert("Box at 0", () => Precision.AlmostEquals(boxQuad.TopLeft, scrollQuad.TopLeft));
+            AddAssert("Box width = 1x", () => Precision.AlmostEquals(boxQuad.Size, scrollQuad.Size));
+        }
+
+        [Test]
+        public void TestZoom10()
+        {
+            reset();
+            AddStep("Set zoom = 10", () => scrollContainer.Zoom = 10);
+            AddAssert("Box at 1/2", () => Precision.AlmostEquals(boxQuad.Centre, scrollQuad.Centre));
+            AddAssert("Box width = 10x", () => Precision.AlmostEquals(boxQuad.Size.X, 10 * scrollQuad.Size.X));
+        }
+
+        [Test]
+        public void TestMouseZoomInOnceOutOnce()
+        {
+            reset();
+
+            // Scroll in at 0.25
+            AddStep("Move mouse to 0.25x", () => InputManager.MoveMouseTo(new Vector2(scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X, scrollQuad.Centre.Y)));
+            AddStep("Press ctrl", () => InputManager.PressKey(Key.LControl));
+            AddStep("Scroll by 3", () => InputManager.ScrollBy(new Vector2(3, 0)));
+            AddStep("Release ctrl", () => InputManager.ReleaseKey(Key.LControl));
+            AddAssert("Box not at 0", () => !Precision.AlmostEquals(boxQuad.TopLeft, scrollQuad.TopLeft));
+            AddAssert("Box 1/4 at 1/4", () => Precision.AlmostEquals(boxQuad.TopLeft.X + 0.25f * boxQuad.Size.X, scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X));
+
+            // Scroll out at 0.25
+            AddStep("Press ctrl", () => InputManager.PressKey(Key.LControl));
+            AddStep("Scroll by -3", () => InputManager.ScrollBy(new Vector2(-3, 0)));
+            AddStep("Release ctrl", () => InputManager.ReleaseKey(Key.LControl));
+            AddAssert("Box at 0", () => Precision.AlmostEquals(boxQuad.TopLeft, scrollQuad.TopLeft));
+            AddAssert("Box 1/4 at 1/4", () => Precision.AlmostEquals(boxQuad.TopLeft.X + 0.25f * boxQuad.Size.X, scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X));
+        }
+
+        [Test]
+        public void TestMouseZoomInTwiceOutTwice()
+        {
+            reset();
+
+            // Scroll in at 0.25
+            AddStep("Move mouse to 0.25x", () => InputManager.MoveMouseTo(new Vector2(scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X, scrollQuad.Centre.Y)));
+            AddStep("Press ctrl", () => InputManager.PressKey(Key.LControl));
+            AddStep("Scroll by 1", () => InputManager.ScrollBy(new Vector2(1, 0)));
+            AddStep("Release ctrl", () => InputManager.ReleaseKey(Key.LControl));
+
+            // Scroll in at 0.6
+            AddStep("Move mouse to 0.75x", () => InputManager.MoveMouseTo(new Vector2(scrollQuad.TopLeft.X + 0.75f * scrollQuad.Size.X, scrollQuad.Centre.Y)));
+            AddStep("Press ctrl", () => InputManager.PressKey(Key.LControl));
+            AddStep("Scroll by 1", () => InputManager.ScrollBy(new Vector2(1, 0)));
+            AddStep("Release ctrl", () => InputManager.ReleaseKey(Key.LControl));
+            AddAssert("Box not at 0", () => !Precision.AlmostEquals(boxQuad.TopLeft, scrollQuad.TopLeft));
+
+            // Very hard to determine actual position, so approximate
+            AddAssert("Box at correct position (1)", () => Precision.DefinitelyBigger(scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X, boxQuad.TopLeft.X + 0.25f * boxQuad.Size.X));
+            AddAssert("Box at correct position (2)", () => Precision.DefinitelyBigger(scrollQuad.TopLeft.X + 0.6f * scrollQuad.Size.X, boxQuad.TopLeft.X + 0.3f * boxQuad.Size.X));
+            AddAssert("Box at correct position (3)", () => Precision.DefinitelyBigger(boxQuad.TopLeft.X + 0.6f * boxQuad.Size.X, scrollQuad.TopLeft.X + 0.6f * scrollQuad.Size.X));
+
+            // Scroll out at 0.6
+            AddStep("Press ctrl", () => InputManager.PressKey(Key.LControl));
+            AddStep("Scroll by -1", () => InputManager.ScrollBy(new Vector2(-1, 0)));
+            AddStep("Release ctrl", () => InputManager.ReleaseKey(Key.LControl));
+
+            // Scroll out at 0.25
+            AddStep("Move mouse to 0.25x", () => InputManager.MoveMouseTo(new Vector2(scrollQuad.TopLeft.X + 0.25f * scrollQuad.Size.X, scrollQuad.Centre.Y)));
+            AddStep("Press ctrl", () => InputManager.PressKey(Key.LControl));
+            AddStep("Scroll by -1", () => InputManager.ScrollBy(new Vector2(-1, 0)));
+            AddStep("Release ctrl", () => InputManager.ReleaseKey(Key.LControl));
+            AddAssert("Box at 0", () => Precision.AlmostEquals(boxQuad.TopLeft, scrollQuad.TopLeft));
+        }
+
+        private void reset()
+        {
+            AddStep("Reset", () =>
+            {
+                scrollContainer.Zoom = 0;
+                scrollContainer.ScrollTo(0, false);
+            });
+        }
+
+        private Quad scrollQuad => scrollContainer.ScreenSpaceDrawQuad;
+        private Quad boxQuad => innerBox.ScreenSpaceDrawQuad;
+    }
+}

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -23,7 +23,6 @@ namespace osu.Game.Beatmaps
         public int BeatmapVersion;
 
         private int? onlineBeatmapID;
-        private int? onlineBeatmapSetID;
 
         [JsonProperty("id")]
         public int? OnlineBeatmapID
@@ -32,19 +31,10 @@ namespace osu.Game.Beatmaps
             set { onlineBeatmapID = value > 0 ? value : null; }
         }
 
-        [JsonProperty("beatmapset_id")]
-        [NotMapped]
-        public int? OnlineBeatmapSetID
-        {
-            get { return onlineBeatmapSetID; }
-            set { onlineBeatmapSetID = value > 0 ? value : null; }
-        }
-
         [JsonIgnore]
         public int BeatmapSetInfoID { get; set; }
 
         [Required]
-        [JsonIgnore]
         public BeatmapSetInfo BeatmapSet { get; set; }
 
         public BeatmapMetadata Metadata { get; set; }
@@ -141,8 +131,8 @@ namespace osu.Game.Beatmaps
                                                       (Metadata ?? BeatmapSet.Metadata).AudioFile == (other.Metadata ?? other.BeatmapSet.Metadata).AudioFile;
 
         public bool BackgroundEquals(BeatmapInfo other) => other != null && BeatmapSet != null && other.BeatmapSet != null &&
-                                                      BeatmapSet.Hash == other.BeatmapSet.Hash &&
-                                                      (Metadata ?? BeatmapSet.Metadata).BackgroundFile == (other.Metadata ?? other.BeatmapSet.Metadata).BackgroundFile;
+                                                           BeatmapSet.Hash == other.BeatmapSet.Hash &&
+                                                           (Metadata ?? BeatmapSet.Metadata).BackgroundFile == (other.Metadata ?? other.BeatmapSet.Metadata).BackgroundFile;
 
         /// <summary>
         /// Returns a shallow-clone of this <see cref="BeatmapInfo"/>.

osu.Game/Beatmaps/BeatmapManager.cs

@@ -81,12 +81,31 @@ namespace osu.Game.Beatmaps
 
         protected override void Populate(BeatmapSetInfo model, ArchiveReader archive)
         {
-            model.Beatmaps = createBeatmapDifficulties(model, archive);
+            model.Beatmaps = createBeatmapDifficulties(archive);
 
-            // remove metadata from difficulties where it matches the set
             foreach (BeatmapInfo b in model.Beatmaps)
+            {
+                // remove metadata from difficulties where it matches the set
                 if (model.Metadata.Equals(b.Metadata))
                     b.Metadata = null;
+
+                // by setting the model here, we can update the noline set id below.
+                b.BeatmapSet = model;
+
+                fetchAndPopulateOnlineIDs(b);
+            }
+
+            // check if a set already exists with the same online id, delete if it does.
+            if (model.OnlineBeatmapSetID != null)
+            {
+                var existingOnlineId = beatmaps.ConsumableItems.FirstOrDefault(b => b.OnlineBeatmapSetID == model.OnlineBeatmapSetID);
+                if (existingOnlineId != null)
+                {
+                    Delete(existingOnlineId);
+                    beatmaps.PurgeDeletable(s => s.ID == existingOnlineId.ID);
+                    Logger.Log($"Found existing beatmap set with same OnlineBeatmapSetID ({model.OnlineBeatmapSetID}). It has been purged.", LoggingTarget.Database);
+                }
+            }
         }
 
         protected override BeatmapSetInfo CheckForExisting(BeatmapSetInfo model)
@@ -99,18 +118,6 @@ namespace osu.Game.Beatmaps
                 return existingHashMatch;
             }
 
-            // check if a set already exists with the same online id
-            if (model.OnlineBeatmapSetID != null)
-            {
-                var existingOnlineId = beatmaps.ConsumableItems.FirstOrDefault(b => b.OnlineBeatmapSetID == model.OnlineBeatmapSetID);
-                if (existingOnlineId != null)
-                {
-                    Delete(existingOnlineId);
-                    beatmaps.PurgeDeletable(s => s.ID == existingOnlineId.ID);
-                    Logger.Log($"Found existing beatmap set with same OnlineBeatmapSetID ({model.OnlineBeatmapSetID}). It has been purged.", LoggingTarget.Database);
-                }
-            }
-
             return null;
         }
 
@@ -306,29 +313,29 @@ namespace osu.Game.Beatmaps
             return hashable.ComputeSHA2Hash();
         }
 
-       protected override BeatmapSetInfo CreateModel(ArchiveReader reader)
+        protected override BeatmapSetInfo CreateModel(ArchiveReader reader)
         {
             // let's make sure there are actually .osu files to import.
             string mapName = reader.Filenames.FirstOrDefault(f => f.EndsWith(".osu"));
             if (string.IsNullOrEmpty(mapName)) throw new InvalidOperationException("No beatmap files found in this beatmap archive.");
 
-            BeatmapMetadata metadata;
+            Beatmap beatmap;
             using (var stream = new StreamReader(reader.GetStream(mapName)))
-                metadata = Decoder.GetDecoder<Beatmap>(stream).Decode(stream).Metadata;
+                beatmap = Decoder.GetDecoder<Beatmap>(stream).Decode(stream);
 
             return new BeatmapSetInfo
             {
-                OnlineBeatmapSetID = metadata.OnlineBeatmapSetID,
+                OnlineBeatmapSetID = beatmap.BeatmapInfo.BeatmapSet?.OnlineBeatmapSetID,
                 Beatmaps = new List<BeatmapInfo>(),
                 Hash = computeBeatmapSetHash(reader),
-                Metadata = metadata
+                Metadata = beatmap.Metadata
             };
         }
 
         /// <summary>
         /// Create all required <see cref="BeatmapInfo"/>s for the provided archive.
         /// </summary>
-        private List<BeatmapInfo> createBeatmapDifficulties(BeatmapSetInfo model, ArchiveReader reader)
+        private List<BeatmapInfo> createBeatmapDifficulties(ArchiveReader reader)
         {
             var beatmapInfos = new List<BeatmapInfo>();
 
@@ -348,10 +355,6 @@ namespace osu.Game.Beatmaps
                     beatmap.BeatmapInfo.Hash = ms.ComputeSHA2Hash();
                     beatmap.BeatmapInfo.MD5Hash = ms.ComputeMD5Hash();
 
-                    // ensure we have the same online set ID as the set itself.
-                    beatmap.BeatmapInfo.OnlineBeatmapSetID = model.OnlineBeatmapSetID;
-                    beatmap.BeatmapInfo.Metadata.OnlineBeatmapSetID = model.OnlineBeatmapSetID;
-
                     // check that no existing beatmap exists that is imported with the same online beatmap ID. if so, give it precedence.
                     if (beatmap.BeatmapInfo.OnlineBeatmapID.HasValue && QueryBeatmap(b => b.OnlineBeatmapID.Value == beatmap.BeatmapInfo.OnlineBeatmapID.Value) != null)
                         beatmap.BeatmapInfo.OnlineBeatmapID = null;
@@ -363,8 +366,7 @@ namespace osu.Game.Beatmaps
                     if (ruleset != null)
                     {
                         // TODO: this should be done in a better place once we actually need to dynamically update it.
-                        var converted = new DummyConversionBeatmap(beatmap).GetPlayableBeatmap(ruleset);
-                        beatmap.BeatmapInfo.StarDifficulty = ruleset.CreateInstance().CreateDifficultyCalculator(converted).Calculate();
+                        beatmap.BeatmapInfo.StarDifficulty = ruleset.CreateInstance().CreateDifficultyCalculator(new DummyConversionBeatmap(beatmap)).Calculate().StarRating;
                     }
                     else
                         beatmap.BeatmapInfo.StarDifficulty = 0;
@@ -376,6 +378,40 @@ namespace osu.Game.Beatmaps
             return beatmapInfos;
         }
 
+        /// <summary>
+        /// Query the API to populate mising OnlineBeatmapID / OnlineBeatmapSetID properties.
+        /// </summary>
+        /// <param name="beatmap">The beatmap to populate.</param>
+        /// <param name="force">Whether to re-query if the provided beatmap already has populated values.</param>
+        /// <returns>True if population was successful.</returns>
+        private bool fetchAndPopulateOnlineIDs(BeatmapInfo beatmap, bool force = false)
+        {
+            if (!force && beatmap.OnlineBeatmapID != null && beatmap.BeatmapSet.OnlineBeatmapSetID != null)
+                return true;
+
+            Logger.Log("Attempting online lookup for IDs...", LoggingTarget.Database);
+
+            try
+            {
+                var req = new GetBeatmapRequest(beatmap);
+
+                req.Perform(api);
+
+                var res = req.Result;
+
+                Logger.Log($"Successfully mapped to {res.OnlineBeatmapSetID} / {res.OnlineBeatmapID}.", LoggingTarget.Database);
+
+                beatmap.BeatmapSet.OnlineBeatmapSetID = res.OnlineBeatmapSetID;
+                beatmap.OnlineBeatmapID = res.OnlineBeatmapID;
+                return true;
+            }
+            catch (Exception e)
+            {
+                Logger.Log($"Failed ({e})", LoggingTarget.Database);
+                return false;
+            }
+        }
+
         /// <summary>
         /// A dummy WorkingBeatmap for the purpose of retrieving a beatmap for star difficulty calculation.
         /// </summary>

osu.Game/Beatmaps/BeatmapMetadata.cs

@@ -17,16 +17,6 @@ namespace osu.Game.Beatmaps
         [JsonIgnore]
         public int ID { get; set; }
 
-        private int? onlineBeatmapSetID;
-
-        [NotMapped]
-        [JsonProperty(@"id")]
-        public int? OnlineBeatmapSetID
-        {
-            get { return onlineBeatmapSetID; }
-            set { onlineBeatmapSetID = value > 0 ? value : null; }
-        }
-
         public string Title { get; set; }
         public string TitleUnicode { get; set; }
         public string Artist { get; set; }
@@ -82,8 +72,7 @@ namespace osu.Game.Beatmaps
             if (other == null)
                 return false;
 
-            return onlineBeatmapSetID == other.onlineBeatmapSetID
-                && Title == other.Title
+            return Title == other.Title
                 && TitleUnicode == other.TitleUnicode
                 && Artist == other.Artist
                 && ArtistUnicode == other.ArtistUnicode

osu.Game/Beatmaps/BeatmapSetInfo.cs

@@ -22,18 +22,18 @@ namespace osu.Game.Beatmaps
         [NotMapped]
         public BeatmapSetOnlineInfo OnlineInfo { get; set; }
 
-        public double MaxStarDifficulty => Beatmaps.Max(b => b.StarDifficulty);
+        public double MaxStarDifficulty => Beatmaps?.Max(b => b.StarDifficulty) ?? 0;
 
         [NotMapped]
         public bool DeletePending { get; set; }
 
         public string Hash { get; set; }
 
-        public string StoryboardFile => Files.FirstOrDefault(f => f.Filename.EndsWith(".osb"))?.Filename;
+        public string StoryboardFile => Files?.FirstOrDefault(f => f.Filename.EndsWith(".osb"))?.Filename;
 
         public List<BeatmapSetFileInfo> Files { get; set; }
 
-        public override string ToString() => Metadata.ToString();
+        public override string ToString() => Metadata?.ToString() ?? base.ToString();
 
         public bool Protected { get; set; }
     }

osu.Game/Beatmaps/DummyWorkingBeatmap.cs

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

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -34,7 +34,8 @@ namespace osu.Game.Beatmaps.Formats
 
         private readonly int offset;
 
-        public LegacyBeatmapDecoder(int version = LATEST_VERSION) : base(version)
+        public LegacyBeatmapDecoder(int version = LATEST_VERSION)
+            : base(version)
         {
             // BeatmapVersion 4 and lower had an incorrect offset (stable has this set as 24ms off)
             offset = FormatVersion < 5 ? 24 : 0;
@@ -135,6 +136,7 @@ namespace osu.Game.Beatmaps.Formats
                             parser = new Rulesets.Objects.Legacy.Mania.ConvertHitObjectParser();
                             break;
                     }
+
                     break;
                 case @"LetterboxInBreaks":
                     beatmap.BeatmapInfo.LetterboxInBreaks = int.Parse(pair.Value) == 1;
@@ -207,8 +209,7 @@ namespace osu.Game.Beatmaps.Formats
                     beatmap.BeatmapInfo.OnlineBeatmapID = int.Parse(pair.Value);
                     break;
                 case @"BeatmapSetID":
-                    beatmap.BeatmapInfo.OnlineBeatmapSetID = int.Parse(pair.Value);
-                    metadata.OnlineBeatmapSetID = int.Parse(pair.Value);
+                    beatmap.BeatmapInfo.BeatmapSet = new BeatmapSetInfo { OnlineBeatmapSetID = int.Parse(pair.Value) };
                     break;
             }
         }

osu.Game/Configuration/DatabasedConfigManager.cs

@@ -13,13 +13,13 @@ namespace osu.Game.Configuration
     {
         private readonly SettingsStore settings;
 
-        private readonly int variant;
+        private readonly int? variant;
 
         private readonly List<DatabasedSetting> databasedSettings;
 
         private readonly RulesetInfo ruleset;
 
-        protected DatabasedConfigManager(SettingsStore settings, RulesetInfo ruleset = null, int variant = 0)
+        protected DatabasedConfigManager(SettingsStore settings, RulesetInfo ruleset = null, int? variant = null)
         {
             this.settings = settings;
             this.ruleset = ruleset;

osu.Game/Configuration/OsuConfigManager.cs

@@ -5,6 +5,7 @@ using osu.Framework.Configuration;
 using osu.Framework.Configuration.Tracking;
 using osu.Framework.Platform;
 using osu.Game.Overlays;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select;
 
 namespace osu.Game.Configuration
@@ -80,6 +81,8 @@ namespace osu.Game.Configuration
 
             Set(OsuSetting.FloatingComments, false);
 
+            Set(OsuSetting.ScoreDisplayMode, ScoringMode.Standardised);
+
             Set(OsuSetting.SpeedChangeVisualisation, SpeedChangeVisualisationMethod.Sequential);
 
             Set(OsuSetting.IncreaseFirstObjectVisibility, true);
@@ -147,6 +150,7 @@ namespace osu.Game.Configuration
         SongSelectRightMouseScroll,
         BeatmapSkins,
         BeatmapHitsounds,
-        IncreaseFirstObjectVisibility
+        IncreaseFirstObjectVisibility,
+        ScoreDisplayMode
     }
 }

osu.Game/Database/OsuDbContext.cs

@@ -181,24 +181,6 @@ namespace osu.Game.Database
             }
         }
 
-        public void Migrate()
-        {
-            try
-            {
-                Database.Migrate();
-            }
-            catch (Exception e)
-            {
-                throw new MigrationFailedException(e);
-            }
-        }
-    }
-
-    public class MigrationFailedException : Exception
-    {
-        public MigrationFailedException(Exception exception)
-            : base("sqlite-net migration failed", exception)
-        {
-        }
+        public void Migrate() => Database.Migrate();
     }
 }

osu.Game/Graphics/Containers/OsuFocusedOverlayContainer.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Graphics.Containers
 
         /// <summary>
         /// Whether mouse input should be blocked screen-wide while this overlay is visible.
-        /// Performing mouse actions outside of the valid extents will hide the overlay but pass the events through.
+        /// Performing mouse actions outside of the valid extents will hide the overlay.
         /// </summary>
         public virtual bool BlockScreenWideMouse => BlockPassThroughMouse;
 

osu.Game/Online/API/APIRequest.cs

@@ -14,16 +14,19 @@ namespace osu.Game.Online.API
     {
         protected override WebRequest CreateWebRequest() => new JsonWebRequest<T>(Uri);
 
+        public T Result => ((JsonWebRequest<T>)WebRequest).ResponseObject;
+
         protected APIRequest()
         {
             base.Success += onSuccess;
         }
 
-        private void onSuccess()
-        {
-            Success?.Invoke(((JsonWebRequest<T>)WebRequest).ResponseObject);
-        }
+        private void onSuccess() => Success?.Invoke(Result);
 
+        /// <summary>
+        /// Invoked on successful completion of an API request.
+        /// This will be scheduled to the API's internal scheduler (run on update thread automatically).
+        /// </summary>
         public new event APISuccessHandler<T> Success;
     }
 
@@ -52,7 +55,16 @@ namespace osu.Game.Online.API
         protected APIAccess API;
         protected WebRequest WebRequest;
 
+        /// <summary>
+        /// Invoked on successful completion of an API request.
+        /// This will be scheduled to the API's internal scheduler (run on update thread automatically).
+        /// </summary>
         public event APISuccessHandler Success;
+
+        /// <summary>
+        /// Invoked on failure to complete an API request.
+        /// This will be scheduled to the API's internal scheduler (run on update thread automatically).
+        /// </summary>
         public event APIFailureHandler Failure;
 
         private bool cancelled;

osu.Game/Online/API/Requests/APIResponseBeatmapSet.cs

@@ -1,149 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System.Collections.Generic;
-using System.Linq;
-using Newtonsoft.Json;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets;
-using System;
-
-namespace osu.Game.Online.API.Requests
-{
-    public class APIResponseBeatmapSet : BeatmapMetadata // todo: this is a bit wrong...
-    {
-        [JsonProperty(@"covers")]
-        private BeatmapSetOnlineCovers covers { get; set; }
-
-        [JsonProperty(@"preview_url")]
-        private string preview { get; set; }
-
-        [JsonProperty(@"play_count")]
-        private int playCount { get; set; }
-
-        [JsonProperty(@"favourite_count")]
-        private int favouriteCount { get; set; }
-
-        [JsonProperty(@"bpm")]
-        private double bpm { get; set; }
-
-        [JsonProperty(@"video")]
-        private bool hasVideo { get; set; }
-
-        [JsonProperty(@"storyboard")]
-        private bool hasStoryboard { get; set; }
-
-        [JsonProperty(@"status")]
-        private BeatmapSetOnlineStatus status { get; set; }
-
-        [JsonProperty(@"submitted_date")]
-        private DateTimeOffset submitted { get; set; }
-
-        [JsonProperty(@"ranked_date")]
-        private DateTimeOffset ranked { get; set; }
-
-        [JsonProperty(@"last_updated")]
-        private DateTimeOffset lastUpdated { get; set; }
-
-        [JsonProperty(@"user_id")]
-        private long creatorId {
-            set { Author.Id = value; }
-        }
-
-        [JsonProperty(@"beatmaps")]
-        private IEnumerable<APIResponseBeatmap> beatmaps { get; set; }
-
-        public BeatmapSetInfo ToBeatmapSet(RulesetStore rulesets)
-        {
-            return new BeatmapSetInfo
-            {
-                OnlineBeatmapSetID = OnlineBeatmapSetID,
-                Metadata = this,
-                OnlineInfo = new BeatmapSetOnlineInfo
-                {
-                    Covers = covers,
-                    Preview = preview,
-                    PlayCount = playCount,
-                    FavouriteCount = favouriteCount,
-                    BPM = bpm,
-                    Status = status,
-                    HasVideo = hasVideo,
-                    HasStoryboard = hasStoryboard,
-                    Submitted = submitted,
-                    Ranked = ranked,
-                    LastUpdated = lastUpdated,
-                },
-                Beatmaps = beatmaps?.Select(b => b.ToBeatmap(rulesets)).ToList(),
-            };
-        }
-
-        private class APIResponseBeatmap : BeatmapMetadata
-        {
-            [JsonProperty(@"id")]
-            private int onlineBeatmapID { get; set; }
-
-            [JsonProperty(@"playcount")]
-            private int playCount { get; set; }
-
-            [JsonProperty(@"passcount")]
-            private int passCount { get; set; }
-
-            [JsonProperty(@"mode_int")]
-            private int ruleset { get; set; }
-
-            [JsonProperty(@"difficulty_rating")]
-            private double starDifficulty { get; set; }
-
-            [JsonProperty(@"drain")]
-            private float drainRate { get; set; }
-
-            [JsonProperty(@"cs")]
-            private float circleSize { get; set; }
-
-            [JsonProperty(@"ar")]
-            private float approachRate { get; set; }
-
-            [JsonProperty(@"accuracy")]
-            private float overallDifficulty { get; set; }
-
-            [JsonProperty(@"total_length")]
-            private double length { get; set; }
-
-            [JsonProperty(@"count_circles")]
-            private int circleCount { get; set; }
-
-            [JsonProperty(@"count_sliders")]
-            private int sliderCount { get; set; }
-
-            [JsonProperty(@"version")]
-            private string version { get; set; }
-
-            public BeatmapInfo ToBeatmap(RulesetStore rulesets)
-            {
-                return new BeatmapInfo
-                {
-                    Metadata = this,
-                    Ruleset = rulesets.GetRuleset(ruleset),
-                    StarDifficulty = starDifficulty,
-                    OnlineBeatmapID = onlineBeatmapID,
-                    Version = version,
-                    BaseDifficulty = new BeatmapDifficulty
-                    {
-                        DrainRate = drainRate,
-                        CircleSize = circleSize,
-                        ApproachRate = approachRate,
-                        OverallDifficulty = overallDifficulty,
-                    },
-                    OnlineInfo = new BeatmapOnlineInfo
-                    {
-                        PlayCount = playCount,
-                        PassCount = passCount,
-                        Length = length,
-                        CircleCount = circleCount,
-                        SliderCount = sliderCount,
-                    },
-                };
-            }
-        }
-    }
-}

osu.Game/Online/API/Requests/GetBeatmapDetailsRequest.cs

@@ -1,46 +1,20 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using Newtonsoft.Json;
 using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Online.API.Requests
 {
-    public class GetBeatmapDetailsRequest : APIRequest<GetBeatmapDetailsResponse>
+    public class GetBeatmapDetailsRequest : APIRequest<APIBeatmapMetrics>
     {
         private readonly BeatmapInfo beatmap;
 
-        private string lookupString => beatmap.OnlineBeatmapID > 0 ? beatmap.OnlineBeatmapID.ToString() : $@"lookup?checksum={beatmap.Hash}&filename={System.Uri.EscapeUriString(beatmap.Path)}";
-
         public GetBeatmapDetailsRequest(BeatmapInfo beatmap)
         {
             this.beatmap = beatmap;
         }
 
-        protected override string Target => $@"beatmaps/{lookupString}";
-    }
-
-    public class GetBeatmapDetailsResponse : BeatmapMetrics
-    {
-        //the online API returns some metrics as a nested object.
-        [JsonProperty(@"failtimes")]
-        private BeatmapMetrics failTimes
-        {
-            set
-            {
-                Fails = value.Fails;
-                Retries = value.Retries;
-            }
-        }
-
-        //and other metrics in the beatmap set.
-        [JsonProperty(@"beatmapset")]
-        private BeatmapMetrics beatmapSet
-        {
-            set
-            {
-                Ratings = value.Ratings;
-            }
-        }
+        protected override string Target => $@"beatmaps/{beatmap.OnlineBeatmapID}";
     }
 }

osu.Game/Online/API/Requests/GetBeatmapRequest.cs

@@ -0,0 +1,22 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Beatmaps;
+using osu.Game.Online.API.Requests.Responses;
+
+namespace osu.Game.Online.API.Requests
+{
+    public class GetBeatmapRequest : APIRequest<APIBeatmap>
+    {
+        private readonly BeatmapInfo beatmap;
+
+        private string lookupString => beatmap.OnlineBeatmapID > 0 ? beatmap.OnlineBeatmapID.ToString() : $@"lookup?checksum={beatmap.MD5Hash}&filename={System.Uri.EscapeUriString(beatmap.Path)}";
+
+        public GetBeatmapRequest(BeatmapInfo beatmap)
+        {
+            this.beatmap = beatmap;
+        }
+
+        protected override string Target => $@"beatmaps/{lookupString}";
+    }
+}

osu.Game/Online/API/Requests/GetBeatmapSetRequest.cs

@@ -1,9 +1,11 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Game.Online.API.Requests.Responses;
+
 namespace osu.Game.Online.API.Requests
 {
-    public class GetBeatmapSetRequest : APIRequest<APIResponseBeatmapSet>
+    public class GetBeatmapSetRequest : APIRequest<APIBeatmapSet>
     {
         private readonly int id;
         private readonly BeatmapSetLookupType type;

osu.Game/Online/API/Requests/GetScoresRequest.cs

@@ -2,20 +2,15 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using Newtonsoft.Json;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
-using osu.Game.Users;
-using osu.Game.Rulesets.Replays;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select.Leaderboards;
 using osu.Framework.IO.Network;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Online.API.Requests
 {
-    public class GetScoresRequest : APIRequest<GetScoresResponse>
+    public class GetScoresRequest : APIRequest<APIScores>
     {
         private readonly BeatmapInfo beatmap;
         private readonly LeaderboardScope scope;
@@ -36,9 +31,9 @@ namespace osu.Game.Online.API.Requests
             Success += onSuccess;
         }
 
-        private void onSuccess(GetScoresResponse r)
+        private void onSuccess(APIScores r)
         {
-            foreach (OnlineScore score in r.Scores)
+            foreach (APIScore score in r.Scores)
                 score.ApplyBeatmap(beatmap);
         }
 
@@ -55,112 +50,4 @@ namespace osu.Game.Online.API.Requests
 
         protected override string Target => $@"beatmaps/{beatmap.OnlineBeatmapID}/scores";
     }
-
-    public class GetScoresResponse
-    {
-        [JsonProperty(@"scores")]
-        public IEnumerable<OnlineScore> Scores;
-    }
-
-    public class OnlineScore : Score
-    {
-        [JsonProperty(@"score")]
-        private double totalScore
-        {
-            set { TotalScore = value; }
-        }
-
-        [JsonProperty(@"max_combo")]
-        private int maxCombo
-        {
-            set { MaxCombo = value; }
-        }
-
-        [JsonProperty(@"user")]
-        private User user
-        {
-            set { User = value; }
-        }
-
-        [JsonProperty(@"replay_data")]
-        private Replay replay
-        {
-            set { Replay = value; }
-        }
-
-        [JsonProperty(@"mode_int")]
-        public int OnlineRulesetID { get; set; }
-
-        [JsonProperty(@"score_id")]
-        private long onlineScoreID
-        {
-            set { OnlineScoreID = value; }
-        }
-
-        [JsonProperty(@"created_at")]
-        private DateTimeOffset date
-        {
-            set { Date = value; }
-        }
-
-        [JsonProperty(@"beatmap")]
-        private BeatmapInfo beatmap
-        {
-            set { Beatmap = value; }
-        }
-
-        [JsonProperty(@"beatmapset")]
-        private BeatmapMetadata metadata
-        {
-            set { Beatmap.Metadata = value; }
-        }
-
-        [JsonProperty(@"statistics")]
-        private Dictionary<string, object> jsonStats
-        {
-            set
-            {
-                foreach (var kvp in value)
-                {
-                    HitResult newKey;
-                    switch (kvp.Key)
-                    {
-                        case @"count_300":
-                            newKey = HitResult.Great;
-                            break;
-                        case @"count_100":
-                            newKey = HitResult.Good;
-                            break;
-                        case @"count_50":
-                            newKey = HitResult.Meh;
-                            break;
-                        case @"count_miss":
-                            newKey = HitResult.Miss;
-                            break;
-                        default:
-                            continue;
-                    }
-
-                    Statistics.Add(newKey, kvp.Value);
-                }
-            }
-        }
-
-        [JsonProperty(@"mods")]
-        private string[] modStrings { get; set; }
-
-        public void ApplyBeatmap(BeatmapInfo beatmap)
-        {
-            Beatmap = beatmap;
-            ApplyRuleset(beatmap.Ruleset);
-        }
-
-        public void ApplyRuleset(RulesetInfo ruleset)
-        {
-            Ruleset = ruleset;
-
-            // Evaluate the mod string
-            Mods = Ruleset.CreateInstance().GetAllMods().Where(mod => modStrings.Contains(mod.ShortenedName)).ToArray();
-        }
-    }
 }

osu.Game/Online/API/Requests/GetUserBeatmapsRequest.cs

@@ -3,10 +3,11 @@
 
 using Humanizer;
 using System.Collections.Generic;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Online.API.Requests
 {
-    public class GetUserBeatmapsRequest : APIRequest<List<APIResponseBeatmapSet>>
+    public class GetUserBeatmapsRequest : APIRequest<List<APIBeatmapSet>>
     {
         private readonly long userId;
         private readonly int offset;

osu.Game/Online/API/Requests/GetUserMostPlayedBeatmapsRequest.cs

@@ -1,14 +1,12 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using Newtonsoft.Json;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets;
 using System.Collections.Generic;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Online.API.Requests
 {
-    public class GetUserMostPlayedBeatmapsRequest : APIRequest<List<MostPlayedBeatmap>>
+    public class GetUserMostPlayedBeatmapsRequest : APIRequest<List<APIUserMostPlayedBeatmap>>
     {
         private readonly long userId;
         private readonly int offset;
@@ -21,28 +19,4 @@ namespace osu.Game.Online.API.Requests
 
         protected override string Target => $@"users/{userId}/beatmapsets/most_played?offset={offset}";
     }
-
-    public class MostPlayedBeatmap
-    {
-        [JsonProperty("beatmap_id")]
-        public int BeatmapID;
-
-        [JsonProperty("count")]
-        public int PlayCount;
-
-        [JsonProperty]
-        private BeatmapInfo beatmap;
-
-        [JsonProperty]
-        private APIResponseBeatmapSet beatmapSet;
-
-        public BeatmapInfo GetBeatmapInfo(RulesetStore rulesets)
-        {
-            BeatmapSetInfo setInfo = beatmapSet.ToBeatmapSet(rulesets);
-            beatmap.BeatmapSet = setInfo;
-            beatmap.OnlineBeatmapSetID = setInfo.OnlineBeatmapSetID;
-            beatmap.Metadata = setInfo.Metadata;
-            return beatmap;
-        }
-    }
 }

osu.Game/Online/API/Requests/GetUserRecentActivitiesRequest.cs

@@ -1,15 +1,12 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using Newtonsoft.Json;
-using osu.Game.Rulesets.Scoring;
-using Humanizer;
-using System;
 using System.Collections.Generic;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Online.API.Requests
 {
-    public class GetUserRecentActivitiesRequest : APIRequest<List<RecentActivity>>
+    public class GetUserRecentActivitiesRequest : APIRequest<List<APIRecentActivity>>
     {
         private readonly long userId;
         private readonly int offset;
@@ -23,86 +20,6 @@ namespace osu.Game.Online.API.Requests
         protected override string Target => $"users/{userId}/recent_activity?offset={offset}";
     }
 
-    public class RecentActivity
-    {
-        [JsonProperty("id")]
-        public int ID;
-
-        [JsonProperty("createdAt")]
-        public DateTimeOffset CreatedAt;
-
-        [JsonProperty]
-        private string type
-        {
-            set => Type = (RecentActivityType)Enum.Parse(typeof(RecentActivityType), value.Pascalize());
-        }
-
-        public RecentActivityType Type;
-
-        [JsonProperty]
-        private string scoreRank
-        {
-            set => ScoreRank = (ScoreRank)Enum.Parse(typeof(ScoreRank), value);
-        }
-
-        public ScoreRank ScoreRank;
-
-        [JsonProperty("rank")]
-        public int Rank;
-
-        [JsonProperty("approval")]
-        public BeatmapApproval Approval;
-
-        [JsonProperty("count")]
-        public int Count;
-
-        [JsonProperty("mode")]
-        public string Mode;
-
-        [JsonProperty("beatmap")]
-        public RecentActivityBeatmap Beatmap;
-
-        [JsonProperty("beatmapset")]
-        public RecentActivityBeatmap Beatmapset;
-
-        [JsonProperty("user")]
-        public RecentActivityUser User;
-
-        [JsonProperty("achievement")]
-        public RecentActivityAchievement Achievement;
-
-        public class RecentActivityBeatmap
-        {
-            [JsonProperty("title")]
-            public string Title;
-
-            [JsonProperty("url")]
-            public string Url;
-        }
-
-        public class RecentActivityUser
-        {
-            [JsonProperty("username")]
-            public string Username;
-
-            [JsonProperty("url")]
-            public string Url;
-
-            [JsonProperty("previousUsername")]
-            public string PreviousUsername;
-        }
-
-        public class RecentActivityAchievement
-        {
-            [JsonProperty("slug")]
-            public string Slug;
-
-            [JsonProperty("name")]
-            public string Name;
-        }
-
-    }
-
     public enum RecentActivityType
     {
         Achievement,

osu.Game/Online/API/Requests/GetUserScoresRequest.cs

@@ -2,10 +2,11 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Online.API.Requests
 {
-    public class GetUserScoresRequest : APIRequest<List<OnlineScore>>
+    public class GetUserScoresRequest : APIRequest<List<APIScore>>
     {
         private readonly long userId;
         private readonly ScoreType type;

osu.Game/Online/API/Requests/GetUsersRequest.cs

@@ -2,19 +2,12 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using Newtonsoft.Json;
-using osu.Game.Users;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Online.API.Requests
 {
-    public class GetUsersRequest : APIRequest<List<RankingEntry>>
+    public class GetUsersRequest : APIRequest<List<APIUser>>
     {
         protected override string Target => @"rankings/osu/performance";
     }
-
-    public class RankingEntry
-    {
-        [JsonProperty]
-        public User User;
-    }
 }

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

@@ -0,0 +1,85 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using Newtonsoft.Json;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APIBeatmap : BeatmapMetadata
+    {
+        [JsonProperty(@"id")]
+        public int OnlineBeatmapID { get; set; }
+
+        [JsonProperty(@"beatmapset_id")]
+        public int OnlineBeatmapSetID { get; set; }
+
+        [JsonProperty(@"playcount")]
+        private int playCount { get; set; }
+
+        [JsonProperty(@"passcount")]
+        private int passCount { get; set; }
+
+        [JsonProperty(@"mode_int")]
+        private int ruleset { get; set; }
+
+        [JsonProperty(@"difficulty_rating")]
+        private double starDifficulty { get; set; }
+
+        [JsonProperty(@"drain")]
+        private float drainRate { get; set; }
+
+        [JsonProperty(@"cs")]
+        private float circleSize { get; set; }
+
+        [JsonProperty(@"ar")]
+        private float approachRate { get; set; }
+
+        [JsonProperty(@"accuracy")]
+        private float overallDifficulty { get; set; }
+
+        [JsonProperty(@"total_length")]
+        private double length { get; set; }
+
+        [JsonProperty(@"count_circles")]
+        private int circleCount { get; set; }
+
+        [JsonProperty(@"count_sliders")]
+        private int sliderCount { get; set; }
+
+        [JsonProperty(@"version")]
+        private string version { get; set; }
+
+        public BeatmapInfo ToBeatmap(RulesetStore rulesets)
+        {
+            return new BeatmapInfo
+            {
+                Metadata = this,
+                Ruleset = rulesets.GetRuleset(ruleset),
+                StarDifficulty = starDifficulty,
+                OnlineBeatmapID = OnlineBeatmapID,
+                BeatmapSet = new BeatmapSetInfo
+                {
+                    OnlineBeatmapSetID = OnlineBeatmapSetID,
+                },
+                Version = version,
+                BaseDifficulty = new BeatmapDifficulty
+                {
+                    DrainRate = drainRate,
+                    CircleSize = circleSize,
+                    ApproachRate = approachRate,
+                    OverallDifficulty = overallDifficulty,
+                },
+                OnlineInfo = new BeatmapOnlineInfo
+                {
+                    PlayCount = playCount,
+                    PassCount = passCount,
+                    Length = length,
+                    CircleCount = circleCount,
+                    SliderCount = sliderCount,
+                },
+            };
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using Newtonsoft.Json;
+using osu.Game.Beatmaps;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APIBeatmapMetrics : BeatmapMetrics
+    {
+        //the online API returns some metrics as a nested object.
+        [JsonProperty(@"failtimes")]
+        private BeatmapMetrics failTimes
+        {
+            set
+            {
+                Fails = value.Fails;
+                Retries = value.Retries;
+            }
+        }
+
+        //and other metrics in the beatmap set.
+        [JsonProperty(@"beatmapset")]
+        private BeatmapMetrics beatmapSet
+        {
+            set => Ratings = value.Ratings;
+        }
+    }
+}

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

@@ -0,0 +1,90 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APIBeatmapSet : BeatmapMetadata // todo: this is a bit wrong...
+    {
+        [JsonProperty(@"covers")]
+        private BeatmapSetOnlineCovers covers { get; set; }
+
+        private int? onlineBeatmapSetID;
+
+        [JsonProperty(@"id")]
+        public int? OnlineBeatmapSetID
+        {
+            get { return onlineBeatmapSetID; }
+            set { onlineBeatmapSetID = value > 0 ? value : null; }
+        }
+
+        [JsonProperty(@"preview_url")]
+        private string preview { get; set; }
+
+        [JsonProperty(@"play_count")]
+        private int playCount { get; set; }
+
+        [JsonProperty(@"favourite_count")]
+        private int favouriteCount { get; set; }
+
+        [JsonProperty(@"bpm")]
+        private double bpm { get; set; }
+
+        [JsonProperty(@"video")]
+        private bool hasVideo { get; set; }
+
+        [JsonProperty(@"storyboard")]
+        private bool hasStoryboard { get; set; }
+
+        [JsonProperty(@"status")]
+        private BeatmapSetOnlineStatus status { get; set; }
+
+        [JsonProperty(@"submitted_date")]
+        private DateTimeOffset submitted { get; set; }
+
+        [JsonProperty(@"ranked_date")]
+        private DateTimeOffset ranked { get; set; }
+
+        [JsonProperty(@"last_updated")]
+        private DateTimeOffset lastUpdated { get; set; }
+
+        [JsonProperty(@"user_id")]
+        private long creatorId
+        {
+            set { Author.Id = value; }
+        }
+
+        [JsonProperty(@"beatmaps")]
+        private IEnumerable<APIBeatmap> beatmaps { get; set; }
+
+        public BeatmapSetInfo ToBeatmapSet(RulesetStore rulesets)
+        {
+            return new BeatmapSetInfo
+            {
+                OnlineBeatmapSetID = OnlineBeatmapSetID,
+                Metadata = this,
+                OnlineInfo = new BeatmapSetOnlineInfo
+                {
+                    Covers = covers,
+                    Preview = preview,
+                    PlayCount = playCount,
+                    FavouriteCount = favouriteCount,
+                    BPM = bpm,
+                    Status = status,
+                    HasVideo = hasVideo,
+                    HasStoryboard = hasStoryboard,
+                    Submitted = submitted,
+                    Ranked = ranked,
+                    LastUpdated = lastUpdated,
+                },
+                Beatmaps = beatmaps?.Select(b => b.ToBeatmap(rulesets)).ToList(),
+            };
+        }
+    }
+}

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

@@ -0,0 +1,89 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using Humanizer;
+using Newtonsoft.Json;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APIRecentActivity
+    {
+        [JsonProperty("id")]
+        public int ID;
+
+        [JsonProperty("createdAt")]
+        public DateTimeOffset CreatedAt;
+
+        [JsonProperty]
+        private string type
+        {
+            set => Type = (RecentActivityType)Enum.Parse(typeof(RecentActivityType), value.Pascalize());
+        }
+
+        public RecentActivityType Type;
+
+        [JsonProperty]
+        private string scoreRank
+        {
+            set => ScoreRank = (ScoreRank)Enum.Parse(typeof(ScoreRank), value);
+        }
+
+        public ScoreRank ScoreRank;
+
+        [JsonProperty("rank")]
+        public int Rank;
+
+        [JsonProperty("approval")]
+        public BeatmapApproval Approval;
+
+        [JsonProperty("count")]
+        public int Count;
+
+        [JsonProperty("mode")]
+        public string Mode;
+
+        [JsonProperty("beatmap")]
+        public RecentActivityBeatmap Beatmap;
+
+        [JsonProperty("beatmapset")]
+        public RecentActivityBeatmap Beatmapset;
+
+        [JsonProperty("user")]
+        public RecentActivityUser User;
+
+        [JsonProperty("achievement")]
+        public RecentActivityAchievement Achievement;
+
+        public class RecentActivityBeatmap
+        {
+            [JsonProperty("title")]
+            public string Title;
+
+            [JsonProperty("url")]
+            public string Url;
+        }
+
+        public class RecentActivityUser
+        {
+            [JsonProperty("username")]
+            public string Username;
+
+            [JsonProperty("url")]
+            public string Url;
+
+            [JsonProperty("previousUsername")]
+            public string PreviousUsername;
+        }
+
+        public class RecentActivityAchievement
+        {
+            [JsonProperty("slug")]
+            public string Slug;
+
+            [JsonProperty("name")]
+            public string Name;
+        }
+    }
+}

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

@@ -0,0 +1,117 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Newtonsoft.Json;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Users;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APIScore : Score
+    {
+        [JsonProperty(@"score")]
+        private double totalScore
+        {
+            set => TotalScore = value;
+        }
+
+        [JsonProperty(@"max_combo")]
+        private int maxCombo
+        {
+            set => MaxCombo = value;
+        }
+
+        [JsonProperty(@"user")]
+        private User user
+        {
+            set => User = value;
+        }
+
+        [JsonProperty(@"replay_data")]
+        private Replay replay
+        {
+            set => Replay = value;
+        }
+
+        [JsonProperty(@"mode_int")]
+        public int OnlineRulesetID { get; set; }
+
+        [JsonProperty(@"score_id")]
+        private long onlineScoreID
+        {
+            set => OnlineScoreID = value;
+        }
+
+        [JsonProperty(@"created_at")]
+        private DateTimeOffset date
+        {
+            set => Date = value;
+        }
+
+        [JsonProperty(@"beatmap")]
+        private BeatmapInfo beatmap
+        {
+            set => Beatmap = value;
+        }
+
+        [JsonProperty(@"beatmapset")]
+        private BeatmapMetadata metadata
+        {
+            set => Beatmap.Metadata = value;
+        }
+
+        [JsonProperty(@"statistics")]
+        private Dictionary<string, object> jsonStats
+        {
+            set
+            {
+                foreach (var kvp in value)
+                {
+                    HitResult newKey;
+                    switch (kvp.Key)
+                    {
+                        case @"count_300":
+                            newKey = HitResult.Great;
+                            break;
+                        case @"count_100":
+                            newKey = HitResult.Good;
+                            break;
+                        case @"count_50":
+                            newKey = HitResult.Meh;
+                            break;
+                        case @"count_miss":
+                            newKey = HitResult.Miss;
+                            break;
+                        default:
+                            continue;
+                    }
+
+                    Statistics.Add(newKey, kvp.Value);
+                }
+            }
+        }
+
+        [JsonProperty(@"mods")]
+        private string[] modStrings { get; set; }
+
+        public void ApplyBeatmap(BeatmapInfo beatmap)
+        {
+            Beatmap = beatmap;
+            ApplyRuleset(beatmap.Ruleset);
+        }
+
+        public void ApplyRuleset(RulesetInfo ruleset)
+        {
+            Ruleset = ruleset;
+
+            // Evaluate the mod string
+            Mods = Ruleset.CreateInstance().GetAllMods().Where(mod => modStrings.Contains(mod.ShortenedName)).ToArray();
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APIScores
+    {
+        [JsonProperty(@"scores")]
+        public IEnumerable<APIScore> Scores;
+    }
+}

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

@@ -0,0 +1,14 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using Newtonsoft.Json;
+using osu.Game.Users;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APIUser
+    {
+        [JsonProperty]
+        public User User;
+    }
+}

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

@@ -0,0 +1,32 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using Newtonsoft.Json;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Online.API.Requests.Responses
+{
+    public class APIUserMostPlayedBeatmap
+    {
+        [JsonProperty("beatmap_id")]
+        public int BeatmapID;
+
+        [JsonProperty("count")]
+        public int PlayCount;
+
+        [JsonProperty]
+        private BeatmapInfo beatmap;
+
+        [JsonProperty]
+        private APIBeatmapSet beatmapSet;
+
+        public BeatmapInfo GetBeatmapInfo(RulesetStore rulesets)
+        {
+            BeatmapSetInfo setInfo = beatmapSet.ToBeatmapSet(rulesets);
+            beatmap.BeatmapSet = setInfo;
+            beatmap.Metadata = setInfo.Metadata;
+            return beatmap;
+        }
+    }
+}

osu.Game/Online/API/Requests/SearchBeatmapSetsRequest.cs

@@ -3,13 +3,14 @@
 
 using System.Collections.Generic;
 using System.ComponentModel;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Direct;
 using osu.Game.Rulesets;
 
 namespace osu.Game.Online.API.Requests
 {
-    public class SearchBeatmapSetsRequest : APIRequest<IEnumerable<APIResponseBeatmapSet>>
+    public class SearchBeatmapSetsRequest : APIRequest<IEnumerable<APIBeatmapSet>>
     {
         private readonly string query;
         private readonly RulesetInfo ruleset;

osu.Game/OsuGameBase.cs

@@ -56,6 +56,8 @@ namespace osu.Game
 
         protected SettingsStore SettingsStore;
 
+        protected RulesetConfigCache RulesetConfigCache;
+
         protected MenuCursorContainer MenuCursorContainer;
 
         private Container content;
@@ -123,6 +125,7 @@ namespace osu.Game
             dependencies.Cache(ScoreStore = new ScoreStore(Host.Storage, contextFactory, Host, BeatmapManager, RulesetStore));
             dependencies.Cache(KeyBindingStore = new KeyBindingStore(contextFactory, RulesetStore));
             dependencies.Cache(SettingsStore = new SettingsStore(contextFactory));
+            dependencies.Cache(RulesetConfigCache = new RulesetConfigCache(SettingsStore));
             dependencies.Cache(new OsuColour());
 
             fileImporters.Add(BeatmapManager);

osu.Game/Overlays/BeatmapSet/Scores/DrawableScore.cs

@@ -9,7 +9,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays.Profile.Sections.Ranks;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
@@ -26,7 +26,7 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
 
         private readonly Box background;
 
-        public DrawableScore(int index, OnlineScore score)
+        public DrawableScore(int index, APIScore score)
         {
             ScoreModsContainer modsContainer;
 

osu.Game/Overlays/BeatmapSet/Scores/DrawableTopScore.cs

@@ -11,7 +11,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
-using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays.Profile.Sections.Ranks;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
@@ -42,8 +42,8 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
         private readonly InfoColumn statistics;
         private readonly ScoreModsContainer modsContainer;
 
-        private OnlineScore score;
-        public OnlineScore Score
+        private APIScore score;
+        public APIScore Score
         {
             get { return score; }
             set

osu.Game/Overlays/BeatmapSet/Scores/ScoresContainer.cs

@@ -11,6 +11,7 @@ using System.Linq;
 using osu.Framework.Allocation;
 using osu.Game.Beatmaps;
 using osu.Game.Online.API;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Overlays.BeatmapSet.Scores
 {
@@ -28,10 +29,10 @@ namespace osu.Game.Overlays.BeatmapSet.Scores
             set => loadingAnimation.FadeTo(value ? 1 : 0, fade_duration);
         }
 
-        private IEnumerable<OnlineScore> scores;
+        private IEnumerable<APIScore> scores;
         private BeatmapInfo beatmap;
 
-        public IEnumerable<OnlineScore> Scores
+        public IEnumerable<APIScore> Scores
         {
             get { return scores; }
             set

osu.Game/Overlays/Direct/DirectGridPanel.cs

@@ -149,7 +149,7 @@ namespace osu.Game.Overlays.Direct
                                             {
                                                 new OsuSpriteText
                                                 {
-                                                    Text = $"{SetInfo.Metadata.Source}",
+                                                    Text = SetInfo.Metadata.Source,
                                                     TextSize = 14,
                                                     Shadow = false,
                                                     Colour = colours.Gray5,

osu.Game/Overlays/Direct/DirectListPanel.cs

@@ -160,7 +160,7 @@ namespace osu.Game.Overlays.Direct
                                         },
                                         new OsuSpriteText
                                         {
-                                            Text = $"from {SetInfo.Metadata.Source}",
+                                            Text = SetInfo.Metadata.Source,
                                             Anchor = Anchor.TopRight,
                                             Origin = Anchor.TopRight,
                                             TextSize = 14,

osu.Game/Overlays/MusicController.cs

@@ -66,34 +66,6 @@ namespace osu.Game.Overlays
             AlwaysPresent = true;
         }
 
-        private Vector2 dragStart;
-
-        protected override bool OnDragStart(InputState state)
-        {
-            base.OnDragStart(state);
-            dragStart = state.Mouse.Position;
-            return true;
-        }
-
-        protected override bool OnDrag(InputState state)
-        {
-            if (base.OnDrag(state)) return true;
-
-            Vector2 change = state.Mouse.Position - dragStart;
-
-            // Diminish the drag distance as we go further to simulate "rubber band" feeling.
-            change *= change.Length <= 0 ? 0 : (float)Math.Pow(change.Length, 0.7f) / change.Length;
-
-            dragContainer.MoveTo(change);
-            return true;
-        }
-
-        protected override bool OnDragEnd(InputState state)
-        {
-            dragContainer.MoveTo(Vector2.Zero, 800, Easing.OutElastic);
-            return base.OnDragEnd(state);
-        }
-
         [BackgroundDependencyLoader]
         private void load(BindableBeatmap beatmap, BeatmapManager beatmaps, OsuColour colours, LocalisationEngine localisation)
         {
@@ -103,7 +75,7 @@ namespace osu.Game.Overlays
 
             Children = new Drawable[]
             {
-                dragContainer = new Container
+                dragContainer = new DragContainer
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -470,5 +442,36 @@ namespace osu.Game.Overlays
                 sprite.Texture = beatmap?.Background ?? textures.Get(@"Backgrounds/bg4");
             }
         }
+
+        private class DragContainer : Container
+        {
+            private Vector2 dragStart;
+
+            protected override bool OnDragStart(InputState state)
+            {
+                base.OnDragStart(state);
+                dragStart = state.Mouse.Position;
+                return true;
+            }
+
+            protected override bool OnDrag(InputState state)
+            {
+                if (base.OnDrag(state)) return true;
+
+                Vector2 change = state.Mouse.Position - dragStart;
+
+                // Diminish the drag distance as we go further to simulate "rubber band" feeling.
+                change *= change.Length <= 0 ? 0 : (float)Math.Pow(change.Length, 0.7f) / change.Length;
+
+                this.MoveTo(change);
+                return true;
+            }
+
+            protected override bool OnDragEnd(InputState state)
+            {
+                this.MoveTo(Vector2.Zero, 800, Easing.OutElastic);
+                return base.OnDragEnd(state);
+            }
+        }
     }
 }

osu.Game/Overlays/Profile/Sections/BeatmapMetadataContainer.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Overlays.Profile.Sections
         {
             Action = () =>
             {
-                if (beatmap.OnlineBeatmapSetID.HasValue) beatmapSetOverlay?.FetchAndShowBeatmapSet(beatmap.OnlineBeatmapSetID.Value);
+                if (beatmap.BeatmapSet?.OnlineBeatmapSetID != null) beatmapSetOverlay?.FetchAndShowBeatmapSet(beatmap.BeatmapSet.OnlineBeatmapSetID.Value);
             };
 
             Child = new FillFlowContainer

osu.Game/Overlays/Profile/Sections/Ranks/PaginatedScoreContainer.cs

@@ -8,6 +8,7 @@ using osu.Game.Online.API.Requests;
 using osu.Game.Users;
 using System;
 using System.Linq;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Overlays.Profile.Sections.Ranks
 {
@@ -49,7 +50,7 @@ namespace osu.Game.Overlays.Profile.Sections.Ranks
 
                 MissingText.Hide();
 
-                foreach (OnlineScore score in scores)
+                foreach (APIScore score in scores)
                 {
                     DrawableProfileScore drawableScore;
 

osu.Game/Overlays/Profile/Sections/Recent/DrawableRecentActivity.cs

@@ -8,6 +8,7 @@ using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Online.Chat;
 using osu.Game.Screens.Select.Leaderboards;
 
@@ -17,11 +18,11 @@ namespace osu.Game.Overlays.Profile.Sections.Recent
     {
         private APIAccess api;
 
-        private readonly RecentActivity activity;
+        private readonly APIRecentActivity activity;
 
         private LinkFlowContainer content;
 
-        public DrawableRecentActivity(RecentActivity activity)
+        public DrawableRecentActivity(APIRecentActivity activity)
         {
             this.activity = activity;
         }

osu.Game/Overlays/Profile/Sections/Recent/PaginatedRecentActivityContainer.cs

@@ -6,6 +6,7 @@ using osu.Framework.Graphics;
 using osu.Game.Online.API.Requests;
 using osu.Game.Users;
 using System.Linq;
+using osu.Game.Online.API.Requests.Responses;
 
 namespace osu.Game.Overlays.Profile.Sections.Recent
 {
@@ -36,7 +37,7 @@ namespace osu.Game.Overlays.Profile.Sections.Recent
 
                 MissingText.Hide();
 
-                foreach (RecentActivity activity in activities)
+                foreach (APIRecentActivity activity in activities)
                 {
                     ItemsContainer.Add(new DrawableRecentActivity(activity));
                 }

osu.Game/Overlays/Settings/RulesetSettingsSubsection.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Overlays.Settings
+{
+    /// <summary>
+    /// A <see cref="SettingsSubsection"/> which provides subclasses with the <see cref="IRulesetConfigManager"/>
+    /// from the <see cref="Ruleset"/>'s <see cref="Ruleset.CreateConfig()"/>.
+    /// </summary>
+    public abstract class RulesetSettingsSubsection : SettingsSubsection
+    {
+        private readonly Ruleset ruleset;
+
+        protected RulesetSettingsSubsection(Ruleset ruleset)
+        {
+            this.ruleset = ruleset;
+        }
+
+        private DependencyContainer dependencies;
+
+        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+        {
+            dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
+
+            var config = dependencies.Get<RulesetConfigCache>().GetConfigFor(ruleset);
+            if (config != null)
+                dependencies.Cache(config);
+
+            return dependencies;
+        }
+    }
+}

osu.Game/Overlays/Settings/Sections/Gameplay/GeneralSettings.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Configuration;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Overlays.Settings.Sections.Gameplay
 {
@@ -38,6 +39,11 @@ namespace osu.Game.Overlays.Settings.Sections.Gameplay
                     LabelText = "Always show key overlay",
                     Bindable = config.GetBindable<bool>(OsuSetting.KeyOverlay)
                 },
+                new SettingsEnumDropdown<ScoringMode>
+                {
+                    LabelText = "Score display mode",
+                    Bindable = config.GetBindable<ScoringMode>(OsuSetting.ScoreDisplayMode)
+                }
             };
         }
     }

osu.Game/Overlays/Volume/VolumeMeter.cs

@@ -24,6 +24,8 @@ namespace osu.Game.Overlays.Volume
     public class VolumeMeter : Container, IKeyBindingHandler<GlobalAction>
     {
         private CircularProgress volumeCircle;
+        private CircularProgress volumeCircleGlow;
+
         public BindableDouble Bindable { get; } = new BindableDouble { MinValue = 0, MaxValue = 1 };
         private readonly float circleSize;
         private readonly Color4 meterColour;
@@ -44,90 +46,143 @@ namespace osu.Game.Overlays.Volume
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            Add(new Container
-            {
-                Size = new Vector2(120, 20),
-                CornerRadius = 10,
-                Masking = true,
-                Margin = new MarginPadding { Left = circleSize + 10 },
-                Origin = Anchor.CentreLeft,
-                Anchor = Anchor.CentreLeft,
-                Children = new Drawable[]
-                {
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = colours.Gray1,
-                        Alpha = 0.9f,
-                    },
-                    new OsuSpriteText
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        Font = "Exo2.0-Bold",
-                        Text = name
-                    }
-                }
-            });
+            Color4 backgroundColour = colours.Gray1;
 
             CircularProgress bgProgress;
 
-            Add(new CircularContainer
+            const float progress_start_radius = 0.75f;
+            const float progress_size = 0.03f;
+            const float progress_end_radius = progress_start_radius + progress_size;
+
+            const float blur_amount = 5;
+
+            Children = new Drawable[]
             {
-                Masking = true,
-                Size = new Vector2(circleSize),
-                Children = new Drawable[]
+                new Container
                 {
-                    new Box
+                    Size = new Vector2(circleSize),
+                    Children = new Drawable[]
                     {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = colours.Gray1,
-                        Alpha = 0.9f,
-                    },
-                    bgProgress = new CircularProgress
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        InnerRadius = 0.05f,
-                        Rotation = 180,
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        Colour = colours.Gray2,
-                        Size = new Vector2(0.8f)
-                    },
-                    new Container
-                    {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        RelativeSizeAxes = Axes.Both,
-                        Size = new Vector2(0.8f),
-                        Padding = new MarginPadding(-Blur.KernelSize(5)),
-                        Rotation = 180,
-                        Child = (volumeCircle = new CircularProgress
+                        new BufferedContainer
                         {
+                            Alpha = 0.9f,
                             RelativeSizeAxes = Axes.Both,
-                            InnerRadius = 0.05f,
+                            Children = new Drawable[]
+                            {
+                                new Circle
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = backgroundColour,
+                                },
+                                new CircularContainer
+                                {
+                                    Masking = true,
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Size = new Vector2(progress_end_radius),
+                                    Children = new Drawable[]
+                                    {
+                                        bgProgress = new CircularProgress
+                                        {
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            RelativeSizeAxes = Axes.Both,
+                                            Rotation = 180,
+                                            Colour = backgroundColour,
+                                        },
+                                        new Container
+                                        {
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            Name = "Progress under covers for smoothing",
+                                            RelativeSizeAxes = Axes.Both,
+                                            Rotation = 180,
+                                            Child = volumeCircle = new CircularProgress
+                                            {
+                                                RelativeSizeAxes = Axes.Both,
+                                            }
+                                        },
+                                    }
+                                },
+                                new Circle
+                                {
+                                    Name = "Inner Cover",
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = backgroundColour,
+                                    Size = new Vector2(progress_start_radius),
+                                },
+                                new Container
+                                {
+                                    Name = "Progress overlay for glow",
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    RelativeSizeAxes = Axes.Both,
+                                    Size = new Vector2(progress_start_radius + progress_size / 1.5f),
+                                    Rotation = 180,
+                                    Padding = new MarginPadding(-Blur.KernelSize(blur_amount)),
+                                    Child = (volumeCircleGlow = new CircularProgress
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        InnerRadius = progress_size * 0.8f,
+                                    }).WithEffect(new GlowEffect
+                                    {
+                                        Colour = meterColour,
+                                        BlurSigma = new Vector2(blur_amount),
+                                        Strength = 5,
+                                        PadExtent = true
+                                    }),
+                                },
+                            },
+                        },
+                        maxGlow = (text = new OsuSpriteText
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Font = "Venera",
+                            TextSize = 0.16f * circleSize
                         }).WithEffect(new GlowEffect
                         {
-                            Colour = meterColour,
-                            Strength = 2,
-                            PadExtent = true
-                        }),
-                    },
-                    maxGlow = (text = new OsuSpriteText
+                            Colour = Color4.Transparent,
+                            PadExtent = true,
+                        })
+                    }
+                },
+                new Container
+                {
+                    Size = new Vector2(120, 20),
+                    CornerRadius = 10,
+                    Masking = true,
+                    Margin = new MarginPadding { Left = circleSize + 10 },
+                    Origin = Anchor.CentreLeft,
+                    Anchor = Anchor.CentreLeft,
+                    Children = new Drawable[]
                     {
-                        Anchor = Anchor.Centre,
-                        Origin = Anchor.Centre,
-                        Font = "Venera",
-                        TextSize = 0.16f * circleSize
-                    }).WithEffect(new GlowEffect
-                    {
-                        Colour = Color4.Transparent,
-                        PadExtent = true,
-                    })
+                        new Box
+                        {
+                            Alpha = 0.9f,
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = backgroundColour,
+                        },
+                        new OsuSpriteText
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Font = "Exo2.0-Bold",
+                            Text = name
+                        }
+                    }
                 }
-            });
-
-            Bindable.ValueChanged += newVolume => { this.TransformTo("DisplayVolume", newVolume, 400, Easing.OutQuint); };
+            };
+            Bindable.ValueChanged += newVolume =>
+            {
+                this.TransformTo("DisplayVolume",
+                    newVolume,
+                    400,
+                    Easing.OutQuint);
+            };
             bgProgress.Current.Value = 0.75f;
         }
 
@@ -158,6 +213,7 @@ namespace osu.Game.Overlays.Volume
                 }
 
                 volumeCircle.Current.Value = displayVolume * 0.75f;
+                volumeCircleGlow.Current.Value = displayVolume * 0.75f;
             }
         }
 

osu.Game/Rulesets/Configuration/RulesetConfigManager.cs

@@ -8,7 +8,8 @@ namespace osu.Game.Rulesets.Configuration
     public abstract class RulesetConfigManager<T> : DatabasedConfigManager<T>, IRulesetConfigManager
         where T : struct
     {
-        protected RulesetConfigManager(SettingsStore settings, RulesetInfo ruleset, int variant) : base(settings, ruleset, variant)
+        protected RulesetConfigManager(SettingsStore settings, RulesetInfo ruleset, int? variant = null)
+            : base(settings, ruleset, variant)
         {
         }
     }

osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs

@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Rulesets.Difficulty
+{
+    public class DifficultyAttributes
+    {
+        public readonly Mod[] Mods;
+        public readonly double StarRating;
+
+        public DifficultyAttributes(Mod[] mods, double starRating)
+        {
+            Mods = mods;
+            StarRating = starRating;
+        }
+    }
+}

osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs

@@ -1,6 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Extensions.IEnumerableExtensions;
@@ -12,30 +13,91 @@ namespace osu.Game.Rulesets.Difficulty
 {
     public abstract class DifficultyCalculator
     {
-        protected readonly IBeatmap Beatmap;
-        protected readonly Mod[] Mods;
+        private readonly Ruleset ruleset;
+        private readonly WorkingBeatmap beatmap;
 
-        protected double TimeRate { get; private set; } = 1;
-
-        protected DifficultyCalculator(IBeatmap beatmap, Mod[] mods = null)
+        protected DifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
         {
-            Beatmap = beatmap;
-            Mods = mods ?? new Mod[0];
-
-            ApplyMods(Mods);
+            this.ruleset = ruleset;
+            this.beatmap = beatmap;
         }
 
-        protected virtual void ApplyMods(Mod[] mods)
+        /// <summary>
+        /// Calculates the difficulty of the beatmap using a specific mod combination.
+        /// </summary>
+        /// <param name="mods">The mods that should be applied to the beatmap.</param>
+        /// <returns>A structure describing the difficulty of the beatmap.</returns>
+        public DifficultyAttributes Calculate(params Mod[] mods)
         {
+            beatmap.Mods.Value = mods;
+            IBeatmap playableBeatmap = beatmap.GetPlayableBeatmap(ruleset.RulesetInfo);
+
             var clock = new StopwatchClock();
             mods.OfType<IApplicableToClock>().ForEach(m => m.ApplyToClock(clock));
-            TimeRate = clock.Rate;
+
+            return Calculate(playableBeatmap, mods, clock.Rate);
         }
 
-        protected virtual void PreprocessHitObjects()
+        /// <summary>
+        /// Calculates the difficulty of the beatmap using all mod combinations applicable to the beatmap.
+        /// </summary>
+        /// <returns>A collection of structures describing the difficulty of the beatmap for each mod combination.</returns>
+        public IEnumerable<DifficultyAttributes> CalculateAll()
         {
+            foreach (var combination in CreateDifficultyAdjustmentModCombinations())
+            {
+                if (combination is MultiMod multi)
+                    yield return Calculate(multi.Mods);
+                else
+                    yield return Calculate(combination);
+            }
         }
 
-        public abstract double Calculate(Dictionary<string, double> categoryDifficulty = null);
+        /// <summary>
+        /// Creates all <see cref="Mod"/> combinations which adjust the <see cref="Beatmap"/> difficulty.
+        /// </summary>
+        public Mod[] CreateDifficultyAdjustmentModCombinations()
+        {
+            return createDifficultyAdjustmentModCombinations(Enumerable.Empty<Mod>(), DifficultyAdjustmentMods).ToArray();
+
+            IEnumerable<Mod> createDifficultyAdjustmentModCombinations(IEnumerable<Mod> currentSet, Mod[] adjustmentSet, int currentSetCount = 0, int adjustmentSetStart = 0)
+            {
+                // Initial-case: Empty current set
+                if (currentSetCount == 0)
+                    yield return new NoModMod();
+
+                if (currentSetCount == 1)
+                    yield return currentSet.Single();
+
+                if (currentSetCount > 1)
+                    yield return new MultiMod(currentSet.ToArray());
+
+                // Apply mods in the adjustment set recursively. Using the entire adjustment set would result in duplicate multi-mod mod
+                // combinations in further recursions, so a moving subset is used to eliminate this effect
+                for (int i = adjustmentSetStart; i < adjustmentSet.Length; i++)
+                {
+                    var adjustmentMod = adjustmentSet[i];
+                    if (currentSet.Any(c => c.IncompatibleMods.Any(m => m.IsInstanceOfType(adjustmentMod))))
+                        continue;
+
+                    foreach (var combo in createDifficultyAdjustmentModCombinations(currentSet.Append(adjustmentMod), adjustmentSet, currentSetCount + 1, i + 1))
+                        yield return combo;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Retrieves all <see cref="Mod"/>s which adjust the <see cref="Beatmap"/> difficulty.
+        /// </summary>
+        protected virtual Mod[] DifficultyAdjustmentMods => Array.Empty<Mod>();
+
+        /// <summary>
+        /// Calculates the difficulty of a <see cref="Beatmap"/> using a specific <see cref="Mod"/> combination.
+        /// </summary>
+        /// <param name="beatmap">The <see cref="IBeatmap"/> to compute the difficulty for.</param>
+        /// <param name="mods">The <see cref="Mod"/>s that should be applied.</param>
+        /// <param name="timeRate">The rate of time in <paramref name="beatmap"/>.</param>
+        /// <returns>A structure containing the difficulty attributes.</returns>
+        protected abstract DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate);
     }
 }

osu.Game/Rulesets/Difficulty/PerformanceCalculator.cs

@@ -13,8 +13,7 @@ namespace osu.Game.Rulesets.Difficulty
 {
     public abstract class PerformanceCalculator
     {
-        private readonly Dictionary<string, double> attributes = new Dictionary<string, double>();
-        protected IDictionary<string, double> Attributes => attributes;
+        protected readonly DifficultyAttributes Attributes;
 
         protected readonly Ruleset Ruleset;
         protected readonly IBeatmap Beatmap;
@@ -22,14 +21,15 @@ namespace osu.Game.Rulesets.Difficulty
 
         protected double TimeRate { get; private set; } = 1;
 
-        protected PerformanceCalculator(Ruleset ruleset, IBeatmap beatmap, Score score)
+        protected PerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, Score score)
         {
             Ruleset = ruleset;
-            Beatmap = beatmap;
             Score = score;
 
-            var diffCalc = ruleset.CreateDifficultyCalculator(beatmap, score.Mods);
-            diffCalc.Calculate(attributes);
+            beatmap.Mods.Value = score.Mods;
+            Beatmap = beatmap.GetPlayableBeatmap(ruleset.RulesetInfo);
+
+            Attributes = ruleset.CreateDifficultyCalculator(beatmap).Calculate(score.Mods);
 
             ApplyMods(score.Mods);
         }

osu.Game/Rulesets/Mods/ModHidden.cs

@@ -27,8 +27,7 @@ namespace osu.Game.Rulesets.Mods
 
         public virtual void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
         {
-            // todo: fix ordering of objects so we don't have to do this (#2740).
-            foreach (var d in drawables.Reverse().Skip(IncreaseFirstObjectVisibility ? 1 : 0))
+            foreach (var d in drawables.Skip(IncreaseFirstObjectVisibility ? 1 : 0))
                 d.ApplyCustomUpdateState += ApplyHiddenState;
         }
 

osu.Game/Rulesets/Mods/ModType.cs

@@ -7,6 +7,6 @@ namespace osu.Game.Rulesets.Mods
     {
         DifficultyReduction,
         DifficultyIncrease,
-        Special,
+        Special
     }
 }

osu.Game/Rulesets/Mods/MultiMod.cs

@@ -1,6 +1,9 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
+using System.Linq;
+
 namespace osu.Game.Rulesets.Mods
 {
     public class MultiMod : Mod
@@ -10,6 +13,13 @@ namespace osu.Game.Rulesets.Mods
         public override string Description => string.Empty;
         public override double ScoreMultiplier => 0;
 
-        public Mod[] Mods;
+        public Mod[] Mods { get; }
+
+        public MultiMod(params Mod[] mods)
+        {
+            Mods = mods;
+        }
+
+        public override Type[] IncompatibleMods => Mods.SelectMany(m => m.IncompatibleMods).ToArray();
     }
 }

osu.Game/Rulesets/Mods/NoModMod.cs

@@ -0,0 +1,15 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Mods
+{
+    /// <summary>
+    /// Indicates a type of mod that doesn't do anything.
+    /// </summary>
+    public sealed class NoModMod : Mod
+    {
+        public override string Name => "No Mod";
+        public override string ShortenedName => "NM";
+        public override double ScoreMultiplier => 1;
+    }
+}

osu.Game/Rulesets/Ruleset.cs

@@ -15,6 +15,8 @@ using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Beatmaps.Legacy;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
 
 namespace osu.Game.Rulesets
@@ -59,9 +61,9 @@ namespace osu.Game.Rulesets
 
         public virtual IBeatmapProcessor CreateBeatmapProcessor(IBeatmap beatmap) => null;
 
-        public abstract DifficultyCalculator CreateDifficultyCalculator(IBeatmap beatmap, Mod[] mods = null);
+        public abstract DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap);
 
-        public virtual PerformanceCalculator CreatePerformanceCalculator(IBeatmap beatmap, Score score) => null;
+        public virtual PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, Score score) => null;
 
         public virtual HitObjectComposer CreateHitObjectComposer() => null;
 
@@ -69,7 +71,13 @@ namespace osu.Game.Rulesets
 
         public abstract string Description { get; }
 
-        public virtual SettingsSubsection CreateSettings() => null;
+        public virtual RulesetSettingsSubsection CreateSettings() => null;
+
+        /// <summary>
+        /// Creates the <see cref="IRulesetConfigManager"/> for this <see cref="Ruleset"/>.
+        /// </summary>
+        /// <param name="settings">The <see cref="SettingsStore"/> to store the settings.</param>
+        public virtual IRulesetConfigManager CreateConfig(SettingsStore settings) => null;
 
         /// <summary>
         /// Do not override this unless you are a legacy mode.

osu.Game/Rulesets/RulesetConfigCache.cs

@@ -0,0 +1,43 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Game.Configuration;
+using osu.Game.Rulesets.Configuration;
+
+namespace osu.Game.Rulesets
+{
+    /// <summary>
+    /// A cache that provides a single <see cref="IRulesetConfigManager"/> per-ruleset.
+    /// This is done to support referring to and updating ruleset configs from multiple locations in the absence of inter-config bindings.
+    /// </summary>
+    public class RulesetConfigCache : Component
+    {
+        private readonly Dictionary<int, IRulesetConfigManager> configCache = new Dictionary<int, IRulesetConfigManager>();
+        private readonly SettingsStore settingsStore;
+
+        public RulesetConfigCache(SettingsStore settingsStore)
+        {
+            this.settingsStore = settingsStore;
+        }
+
+        /// <summary>
+        /// Retrieves the <see cref="IRulesetConfigManager"/> for a <see cref="Ruleset"/>.
+        /// </summary>
+        /// <param name="ruleset">The <see cref="Ruleset"/> to retrieve the <see cref="IRulesetConfigManager"/> for.</param>
+        /// <returns>The <see cref="IRulesetConfigManager"/> defined by <paramref name="ruleset"/>, null if <paramref name="ruleset"/> doesn't define one.</returns>
+        /// <exception cref="InvalidOperationException">If <paramref name="ruleset"/> doesn't have a valid <see cref="RulesetInfo.ID"/>.</exception>
+        public IRulesetConfigManager GetConfigFor(Ruleset ruleset)
+        {
+            if (ruleset.RulesetInfo.ID == null)
+                throw new InvalidOperationException("The provided ruleset doesn't have a valid id.");
+
+            if (configCache.TryGetValue(ruleset.RulesetInfo.ID.Value, out var existing))
+                return existing;
+
+            return configCache[ruleset.RulesetInfo.ID.Value] = ruleset.CreateConfig(settingsStore);
+        }
+    }
+}

osu.Game/Rulesets/Scoring/ScoreProcessor.cs

@@ -65,6 +65,11 @@ namespace osu.Game.Rulesets.Scoring
         /// </summary>
         public readonly BindableInt HighestCombo = new BindableInt();
 
+        /// <summary>
+        /// The <see cref="ScoringMode"/> used to calculate scores.
+        /// </summary>
+        public readonly Bindable<ScoringMode> Mode = new Bindable<ScoringMode>();
+
         /// <summary>
         /// Whether all <see cref="Judgement"/>s have been processed.
         /// </summary>
@@ -169,8 +174,6 @@ namespace osu.Game.Rulesets.Scoring
         private const double combo_portion = 0.7;
         private const double max_score = 1000000;
 
-        public readonly Bindable<ScoringMode> Mode = new Bindable<ScoringMode>();
-
         protected sealed override bool HasCompleted => JudgedHits == MaxHits;
 
         protected int MaxHits { get; private set; }
@@ -199,16 +202,18 @@ namespace osu.Game.Rulesets.Scoring
 
             if (maxBaseScore == 0 || maxHighestCombo == 0)
             {
-                Mode.Value = ScoringMode.Exponential;
+                Mode.Value = ScoringMode.Classic;
                 Mode.Disabled = true;
             }
+
+            Mode.ValueChanged += _ => updateScore();
         }
 
         /// <summary>
         /// Simulates an autoplay of <see cref="HitObject"/>s that will be judged by this <see cref="ScoreProcessor{TObject}"/>
         /// by adding <see cref="Judgement"/>s for each <see cref="HitObject"/> in the <see cref="Beatmap{TObject}"/>.
         /// <para>
-        /// This is required for <see cref="ScoringMode.Standardised"/> to work, otherwise <see cref="ScoringMode.Exponential"/> will be used.
+        /// This is required for <see cref="ScoringMode.Standardised"/> to work, otherwise <see cref="ScoringMode.Classic"/> will be used.
         /// </para>
         /// </summary>
         /// <param name="beatmap">The <see cref="Beatmap{TObject}"/> containing the <see cref="HitObject"/>s that will be judged by this <see cref="ScoreProcessor{TObject}"/>.</param>
@@ -295,8 +300,9 @@ namespace osu.Game.Rulesets.Scoring
                 case ScoringMode.Standardised:
                     TotalScore.Value = max_score * (base_portion * baseScore / maxBaseScore + combo_portion * HighestCombo / maxHighestCombo) + bonusScore;
                     break;
-                case ScoringMode.Exponential:
-                    TotalScore.Value = (baseScore + bonusScore) * Math.Log(HighestCombo + 1, 2);
+                case ScoringMode.Classic:
+                    // should emulate osu-stable's scoring as closely as we can (https://osu.ppy.sh/help/wiki/Score/ScoreV1)
+                    TotalScore.Value = bonusScore + baseScore * (1 + Math.Max(0, HighestCombo - 1) / 25);
                     break;
             }
         }
@@ -322,6 +328,6 @@ namespace osu.Game.Rulesets.Scoring
     public enum ScoringMode
     {
         Standardised,
-        Exponential
+        Classic
     }
 }