Merge branch 'master' into user-profile-recent

osu-framework

@@ -1 +1 @@
-Subproject commit e8ae207769ec26fb7ddd67a2433514fcda354ecd
+Subproject commit 6372fb22c1c85f600921a139849b8dedf71026d5

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -101,7 +101,7 @@ namespace osu.Game.Rulesets.Catch
 
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new CatchDifficultyCalculator(beatmap);
 
-        public override int LegacyID => 2;
+        public override int? LegacyID => 2;
 
         public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new CatchReplayFrame();
 

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -114,7 +114,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new ManiaDifficultyCalculator(beatmap);
 
-        public override int LegacyID => 3;
+        public override int? LegacyID => 3;
 
         public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new ManiaReplayFrame();
 

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

@@ -50,10 +50,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void UpdatePreemptState()
         {
-            this.Animate(
+            this.FadeOut().FadeIn(ANIM_DURATION);
-                d => d.FadeIn(ANIM_DURATION),
+            this.ScaleTo(0.5f).ScaleTo(1f, ANIM_DURATION * 4, Easing.OutElasticHalf);
-                d => d.ScaleTo(0.5f).ScaleTo(1f, ANIM_DURATION * 4, Easing.OutElasticHalf)
-            );
         }
 
         protected override void UpdateCurrentState(ArmedState state)
@@ -64,12 +62,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     this.Delay(HitObject.TimePreempt).FadeOut();
                     break;
                 case ArmedState.Miss:
-                    this.FadeOut(ANIM_DURATION)
+                    this.FadeOut(ANIM_DURATION);
-                        .FadeColour(Color4.Red, ANIM_DURATION / 2);
+                    this.FadeColour(Color4.Red, ANIM_DURATION / 2);
                     break;
                 case ArmedState.Hit:
-                    this.FadeOut(ANIM_DURATION, Easing.OutQuint)
+                    this.FadeOut(ANIM_DURATION, Easing.OutQuint);
-                        .ScaleTo(Scale * 1.5f, ANIM_DURATION, Easing.Out);
+                    this.ScaleTo(Scale * 1.5f, ANIM_DURATION, Easing.Out);
                     break;
             }
         }

osu.Game.Rulesets.Osu/Objects/Spinner.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 osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.ControlPoints;
@@ -26,7 +27,7 @@ namespace osu.Game.Rulesets.Osu.Objects
             SpinsRequired = (int)(Duration / 1000 * BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5));
 
             // spinning doesn't match 1:1 with stable, so let's fudge them easier for the time being.
-            SpinsRequired = (int)(SpinsRequired * 0.6);
+            SpinsRequired = (int)Math.Max(1, SpinsRequired * 0.6);
         }
     }
 }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -145,7 +145,7 @@ namespace osu.Game.Rulesets.Osu
 
         public override SettingsSubsection CreateSettings() => new OsuSettings();
 
-        public override int LegacyID => 0;
+        public override int? LegacyID => 0;
 
         public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new OsuReplayFrame();
 

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs

@@ -101,16 +101,16 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 // The duration of the taiko hit object
                 double taikoDuration = distance / taikoVelocity;
 
-                // For some reason, old osu! always uses speedAdjustment to determine the taiko velocity, but
-                // only uses it to determine osu! velocity if beatmap version < 8. Let's account for that here.
-                if (beatmap.BeatmapInfo.BeatmapVersion >= 8)
-                    speedAdjustedBeatLength *= speedAdjustment;
-
                 // The velocity of the osu! hit object - calculated as the velocity of a slider
                 double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier * legacy_velocity_multiplier / speedAdjustedBeatLength;
                 // The duration of the osu! hit object
                 double osuDuration = distance / osuVelocity;
 
+                // osu-stable always uses the speed-adjusted beatlength to determine the velocities, but
+                // only uses it for tick rate if beatmap version < 8
+                if (beatmap.BeatmapInfo.BeatmapVersion >= 8)
+                    speedAdjustedBeatLength *= speedAdjustment;
+
                 // If the drum roll is to be split into hit circles, assume the ticks are 1/8 spaced within the duration of one beat
                 double tickSpacing = Math.Min(speedAdjustedBeatLength / beatmap.BeatmapInfo.BaseDifficulty.SliderTickRate, taikoDuration / spans);
 

osu.Game.Rulesets.Taiko/Objects/Drawables/DrawableDrumRoll.cs

@@ -82,8 +82,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 return;
 
             int countHit = NestedHitObjects.Count(o => o.IsHit);
-
+            if (countHit >= HitObject.RequiredGoodHits)
-            if (countHit > HitObject.RequiredGoodHits)
             {
                 AddJudgement(new TaikoJudgement { Result = countHit >= HitObject.RequiredGreatHits ? HitResult.Great : HitResult.Good });
                 if (HitObject.IsStrong)

osu.Game.Rulesets.Taiko/Resources/Testing/Beatmaps/slider-generating-drumroll-expected-conversion.json

@@ -0,0 +1,87 @@
+{
+    "Mappings": [{
+            "StartTime": 6590,
+            "Objects": [{
+                "StartTime": 6590,
+                "EndTime": 8320,
+                "IsRim": false,
+                "IsCentre": false,
+                "IsDrumRoll": true,
+                "IsSwell": false,
+                "IsStrong": false
+            }]
+        },
+        {
+            "StartTime": 8436,
+            "Objects": [{
+                "StartTime": 8436,
+                "EndTime": 10166,
+                "IsRim": false,
+                "IsCentre": false,
+                "IsDrumRoll": true,
+                "IsSwell": false,
+                "IsStrong": false
+            }]
+        },
+        {
+            "StartTime": 10282,
+            "Objects": [{
+                "StartTime": 10282,
+                "EndTime": 12012,
+                "IsRim": false,
+                "IsCentre": false,
+                "IsDrumRoll": true,
+                "IsSwell": false,
+                "IsStrong": false
+            }]
+        },
+        {
+            "StartTime": 12128,
+            "Objects": [{
+                "StartTime": 12128,
+                "EndTime": 13858,
+                "IsRim": false,
+                "IsCentre": false,
+                "IsDrumRoll": true,
+                "IsSwell": false,
+                "IsStrong": false
+            }]
+        },
+        {
+            "StartTime": 41666,
+            "Objects": [{
+                "StartTime": 41666,
+                "EndTime": 42589,
+                "IsRim": false,
+                "IsCentre": false,
+                "IsDrumRoll": true,
+                "IsSwell": false,
+                "IsStrong": false
+            }]
+        },
+        {
+            "StartTime": 62666,
+            "Objects": [{
+                "StartTime": 62666,
+                "EndTime": 63127,
+                "IsRim": false,
+                "IsCentre": false,
+                "IsDrumRoll": true,
+                "IsSwell": false,
+                "IsStrong": false
+            }]
+        },
+        {
+            "StartTime": 208743,
+            "Objects": [{
+                "StartTime": 208743,
+                "EndTime": 209204,
+                "IsRim": false,
+                "IsCentre": false,
+                "IsDrumRoll": true,
+                "IsSwell": false,
+                "IsStrong": false
+            }]
+        }
+    ]
+}

osu.Game.Rulesets.Taiko/Resources/Testing/Beatmaps/slider-generating-drumroll.osu

@@ -0,0 +1,25 @@
+osu file format v14
+
+[Difficulty]
+HPDrainRate:6
+CircleSize:4.2
+OverallDifficulty:9
+ApproachRate:9.8
+SliderMultiplier:1.87
+SliderTickRate:1
+
+[TimingPoints]
+6590,461.538461538462,4,2,2,15,1,0
+6590,-200,4,2,2,15,0,0
+49051,230.769230769231,4,2,1,15,1,0
+62666,-200,4,2,1,60,0,0
+197666,-100,4,2,1,85,0,1
+
+[HitObjects]
+88,104,6590,6,0,B|176:156|256:108|256:108|336:60|423:112,1,350.625,6|0,0:0|0:0,0:0:0:0:
+396,213,8436,2,0,P|277:247|376:172,1,350.625,6|0,0:0|0:0,0:0:0:0:
+472,220,10282,2,0,P|456:288|220:300,1,350.625,6|0,0:0|0:0,0:0:0:0:
+277,200,12128,2,0,P|398:225|276:244,1,350.625,6|0,0:0|0:0,0:0:0:0:
+268,229,41666,2,0,L|473:210,1,187,2|2,0:0|0:0,0:0:0:0:
+133,342,62666,2,0,B|132:316|132:316|128:316|128:316|130:295|130:295|126:296|126:296|129:275|129:275|125:275|125:275|127:254|127:254|123:255|123:255|125:234|125:234|121:234|121:234|123:213|123:213|119:214|119:214|121:193|121:193|118:193|118:193|118:172,1,187,8|8,0:0|0:0,0:0:0:0:
+481,338,208743,6,0,P|492:262|383:195,2,187,2|8|2,0:0|0:0|0:0,0:0:0:0:

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Taiko
 
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new TaikoDifficultyCalculator(beatmap);
 
-        public override int LegacyID => 1;
+        public override int? LegacyID => 1;
 
         public override IConvertibleReplayFrame CreateConvertibleReplayFrame() => new TaikoReplayFrame();
 

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

@@ -22,6 +22,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
 
         [NonParallelizable]
         [TestCase("basic", false), Ignore("See: https://github.com/ppy/osu/issues/2152")]
+        [TestCase("slider-generating-drumroll", false)]
         public void Test(string name, bool isForCurrentRuleset)
         {
             this.isForCurrentRuleset = isForCurrentRuleset;

osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj

@@ -149,6 +149,8 @@
   <ItemGroup>
     <EmbeddedResource Include="Resources\Testing\Beatmaps\basic-expected-conversion.json" />
     <EmbeddedResource Include="Resources\Testing\Beatmaps\basic.osu" />
+    <EmbeddedResource Include="Resources\Testing\Beatmaps\slider-generating-drumroll-expected-conversion.json" />
+    <EmbeddedResource Include="Resources\Testing\Beatmaps\slider-generating-drumroll.osu" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\packages\SQLitePCLRaw.lib.e_sqlite3.linux.1.1.8\build\net35\SQLitePCLRaw.lib.e_sqlite3.linux.targets" Condition="Exists('$(SolutionDir)\packages\SQLitePCLRaw.lib.e_sqlite3.linux.1.1.8\build\net35\SQLitePCLRaw.lib.e_sqlite3.linux.targets')" />

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

@@ -20,7 +20,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
         [Test]
         public void TestDecodeBeatmapGeneral()
         {
-            var decoder = new LegacyBeatmapDecoder();
+            var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
             using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
             using (var stream = new StreamReader(resStream))
             {
@@ -102,7 +102,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.AreEqual(4, difficulty.CircleSize);
                 Assert.AreEqual(8, difficulty.OverallDifficulty);
                 Assert.AreEqual(9, difficulty.ApproachRate);
-                Assert.AreEqual(1.8f, difficulty.SliderMultiplier);
+                Assert.AreEqual(1.8, difficulty.SliderMultiplier);
                 Assert.AreEqual(2, difficulty.SliderTickRate);
             }
         }
@@ -110,7 +110,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
         [Test]
         public void TestDecodeBeatmapEvents()
         {
-            var decoder = new LegacyBeatmapDecoder();
+            var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
             using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
             using (var stream = new StreamReader(resStream))
             {
@@ -128,7 +128,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
         [Test]
         public void TestDecodeBeatmapTimingPoints()
         {
-            var decoder = new LegacyBeatmapDecoder();
+            var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
             using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
             using (var stream = new StreamReader(resStream))
             {
@@ -187,7 +187,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
         [Test]
         public void TestDecodeBeatmapHitObjects()
         {
-            var decoder = new LegacyBeatmapDecoder();
+            var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
             using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
             using (var stream = new StreamReader(resStream))
             {

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

@@ -85,7 +85,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             Assert.AreEqual(4, difficulty.CircleSize);
             Assert.AreEqual(8, difficulty.OverallDifficulty);
             Assert.AreEqual(9, difficulty.ApproachRate);
-            Assert.AreEqual(1.8f, difficulty.SliderMultiplier);
+            Assert.AreEqual(1.8, difficulty.SliderMultiplier);
             Assert.AreEqual(2, difficulty.SliderTickRate);
         }
 
@@ -159,7 +159,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var sr = new StreamReader(stream))
             {
 
-                var legacyDecoded = new LegacyBeatmapDecoder().DecodeBeatmap(sr);
+                var legacyDecoded = new LegacyBeatmapDecoder { ApplyOffsets = false }.DecodeBeatmap(sr);
                 using (var ms = new MemoryStream())
                 using (var sw = new StreamWriter(ms))
                 using (var sr2 = new StreamReader(ms))

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

@@ -58,7 +58,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);
                 Assert.AreEqual("Deif", meta.AuthorString);
                 Assert.AreEqual("machinetop_background.jpg", meta.BackgroundFile);
-                Assert.AreEqual(164471, meta.PreviewTime);
+                Assert.AreEqual(164471 + LegacyBeatmapDecoder.UniversalOffset, meta.PreviewTime);
                 Assert.AreEqual(string.Empty, meta.Source);
                 Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", meta.Tags);
                 Assert.AreEqual("Renatus", meta.Title);

osu.Game.Tests/Visual/TestCaseVolumePieces.cs

@@ -0,0 +1,30 @@
+// 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.Overlays.Volume;
+using OpenTK.Graphics;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseVolumePieces : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(VolumeMeter), typeof(MuteButton) };
+
+        protected override void LoadComplete()
+        {
+            VolumeMeter meter;
+            MuteButton mute;
+            Add(meter = new VolumeMeter("MASTER", 125, Color4.Blue));
+            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/osu.Game.Tests.csproj

@@ -174,6 +174,7 @@
     <Compile Include="Visual\TestCaseUserPanel.cs" />
     <Compile Include="Visual\TestCaseUserProfile.cs" />
     <Compile Include="Visual\TestCaseUserRanks.cs" />
+    <Compile Include="Visual\TestCaseVolumePieces.cs" />
     <Compile Include="Visual\TestCaseWaveform.cs" />
   </ItemGroup>
   <ItemGroup>

osu.Game/Beatmaps/BeatmapDifficulty.cs

@@ -29,8 +29,8 @@ namespace osu.Game.Beatmaps
             set => approachRate = value;
         }
 
-        public float SliderMultiplier { get; set; } = 1;
+        public double SliderMultiplier { get; set; } = 1;
-        public float SliderTickRate { get; set; } = 1;
+        public double SliderTickRate { get; set; } = 1;
 
         /// <summary>
         /// Maps a difficulty value [0, 10] to a two-piece linear range of values.

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -8,6 +8,7 @@ using OpenTK.Graphics;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Framework;
 
 namespace osu.Game.Beatmaps.Formats
 {
@@ -21,6 +22,19 @@ namespace osu.Game.Beatmaps.Formats
         private LegacySampleBank defaultSampleBank;
         private int defaultSampleVolume = 100;
 
+        /// <summary>
+        /// lazer's audio timings in general doesn't match stable. this is the result of user testing, albeit limited.
+        /// This only seems to be required on windows. We need to eventually figure out why, with a bit of luck.
+        /// </summary>
+        public static int UniversalOffset => RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? -22 : 0;
+
+        /// <summary>
+        /// Whether or not beatmap or runtime offsets should be applied. Defaults on; only disable for testing purposes.
+        /// </summary>
+        public bool ApplyOffsets = true;
+
+        private readonly int offset = UniversalOffset;
+
         public LegacyBeatmapDecoder()
         {
         }
@@ -28,6 +42,9 @@ namespace osu.Game.Beatmaps.Formats
         public LegacyBeatmapDecoder(string header)
         {
             BeatmapVersion = int.Parse(header.Substring(17));
+
+            // BeatmapVersion 4 and lower had an incorrect offset (stable has this set as 24ms off)
+            offset += BeatmapVersion < 5 ? 24 : 0;
         }
 
         protected override void ParseBeatmap(StreamReader stream, Beatmap beatmap)
@@ -102,7 +119,7 @@ namespace osu.Game.Beatmaps.Formats
                     beatmap.BeatmapInfo.AudioLeadIn = int.Parse(pair.Value);
                     break;
                 case @"PreviewTime":
-                    metadata.PreviewTime = int.Parse(pair.Value);
+                    metadata.PreviewTime = getOffsetTime(int.Parse(pair.Value));
                     break;
                 case @"Countdown":
                     beatmap.BeatmapInfo.Countdown = int.Parse(pair.Value) == 1;
@@ -232,10 +249,10 @@ namespace osu.Game.Beatmaps.Formats
                     difficulty.ApproachRate = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
                     break;
                 case @"SliderMultiplier":
-                    difficulty.SliderMultiplier = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    difficulty.SliderMultiplier = double.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
                     break;
                 case @"SliderTickRate":
-                    difficulty.SliderTickRate = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    difficulty.SliderTickRate = double.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
                     break;
             }
         }
@@ -257,8 +274,8 @@ namespace osu.Game.Beatmaps.Formats
                 case EventType.Break:
                     var breakEvent = new BreakPeriod
                     {
-                        StartTime = double.Parse(split[1], NumberFormatInfo.InvariantInfo),
+                        StartTime = getOffsetTime(double.Parse(split[1], NumberFormatInfo.InvariantInfo)),
-                        EndTime = double.Parse(split[2], NumberFormatInfo.InvariantInfo)
+                        EndTime = getOffsetTime(double.Parse(split[2], NumberFormatInfo.InvariantInfo))
                     };
 
                     if (!breakEvent.HasEffect)
@@ -273,7 +290,7 @@ namespace osu.Game.Beatmaps.Formats
         {
             string[] split = line.Split(',');
 
-            double time = double.Parse(split[0].Trim(), NumberFormatInfo.InvariantInfo);
+            double time = getOffsetTime(double.Parse(split[0].Trim(), NumberFormatInfo.InvariantInfo));
             double beatLength = double.Parse(split[1].Trim(), NumberFormatInfo.InvariantInfo);
             double speedMultiplier = beatLength < 0 ? 100.0 / -beatLength : 1;
 
@@ -396,7 +413,14 @@ namespace osu.Game.Beatmaps.Formats
             var obj = parser.Parse(line);
 
             if (obj != null)
+            {
+                obj.StartTime = getOffsetTime(obj.StartTime);
                 beatmap.HitObjects.Add(obj);
+            }
         }
+
+        private int getOffsetTime(int time) => time + (ApplyOffsets ? offset : 0);
+
+        private double getOffsetTime(double time) => time + (ApplyOffsets ? offset : 0);
     }
 }

osu.Game/Graphics/Containers/ParallaxContainer.cs

@@ -66,7 +66,7 @@ namespace osu.Game.Graphics.Containers
             {
                 Vector2 offset = (input.CurrentState.Mouse == null ? Vector2.Zero : ToLocalSpace(input.CurrentState.Mouse.NativeState.Position) - DrawSize / 2) * ParallaxAmount;
 
-                content.Position = Interpolation.ValueAt(Clock.ElapsedFrameTime, content.Position, offset, 0, 1000, Easing.OutQuint);
+                content.Position = Interpolation.ValueAt(MathHelper.Clamp(Clock.ElapsedFrameTime, 0, 1000), content.Position, offset, 0, 1000, Easing.OutQuint);
                 content.Scale = new Vector2(1 + ParallaxAmount);
             }
 

osu.Game/Graphics/Containers/ReverseChildIDFillFlowContainer.cs

@@ -1,8 +1,6 @@
 // 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 osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 
@@ -11,7 +9,5 @@ namespace osu.Game.Graphics.Containers
     public class ReverseChildIDFillFlowContainer<T> : FillFlowContainer<T> where T : Drawable
     {
         protected override int Compare(Drawable x, Drawable y) => CompareReverseChildID(x, y);
-
-        protected override IEnumerable<Drawable> FlowingChildren => base.FlowingChildren.Reverse();
     }
 }

osu.Game/Graphics/UserInterface/FocusedTextBox.cs

@@ -18,8 +18,6 @@ namespace osu.Game.Graphics.UserInterface
 
         public Action Exit;
 
-        public override bool HandleLeftRightArrows => false;
-
         private bool focus;
         public bool HoldFocus
         {

osu.Game/Graphics/UserInterface/OsuTabControl.cs

@@ -9,6 +9,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
@@ -56,6 +57,14 @@ namespace osu.Game.Graphics.UserInterface
             }
         }
 
+        protected override TabFillFlowContainer CreateTabFlow() => new OsuTabFillFlowContainer
+        {
+            Direction = FillDirection.Full,
+            RelativeSizeAxes = Axes.Both,
+            Depth = -1,
+            Masking = true
+        };
+
         public class OsuTabItem : TabItem<T>, IHasAccentColour
         {
             protected readonly SpriteText Text;
@@ -239,5 +248,10 @@ namespace osu.Game.Graphics.UserInterface
                 }
             }
         }
+
+        private class OsuTabFillFlowContainer : TabFillFlowContainer
+        {
+            protected override int Compare(Drawable x, Drawable y) => CompareReverseChildID(x, y);
+        }
     }
 }

osu.Game/Graphics/UserInterface/SearchTextBox.cs

@@ -12,6 +12,8 @@ namespace osu.Game.Graphics.UserInterface
     {
         protected virtual bool AllowCommit => false;
 
+        public override bool HandleLeftRightArrows => false;
+
         public SearchTextBox()
         {
             Height = 35;

osu.Game/Graphics/UserInterface/Volume/VolumeMeter.cs

@@ -1,108 +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 osu.Framework.Configuration;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Graphics.Sprites;
-using OpenTK;
-using OpenTK.Graphics;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.Bindings;
-using osu.Game.Input.Bindings;
-
-namespace osu.Game.Graphics.UserInterface.Volume
-{
-    public class VolumeMeter : Container, IKeyBindingHandler<GlobalAction>
-    {
-        private readonly Box meterFill;
-        public BindableDouble Bindable { get; } = new BindableDouble();
-
-        public VolumeMeter(string meterName)
-        {
-            Size = new Vector2(40, 180);
-            Children = new Drawable[]
-            {
-                new Box
-                {
-                    Colour = Color4.Black,
-                    RelativeSizeAxes = Axes.Both
-                },
-                new Container
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Size = new Vector2(0.5f, 0.9f),
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Children = new Drawable[]
-                    {
-                        new Box
-                        {
-                            Colour = Color4.DarkGray,
-                            RelativeSizeAxes = Axes.Both
-                        },
-                        meterFill = new Box
-                        {
-                            Colour = Color4.White,
-                            Scale = new Vector2(1, 0),
-                            RelativeSizeAxes = Axes.Both,
-                            Origin = Anchor.BottomCentre,
-                            Anchor = Anchor.BottomCentre
-                        }
-                    }
-                },
-                new OsuSpriteText
-                {
-                    Text = meterName,
-                    Anchor = Anchor.BottomCentre,
-                    Origin = Anchor.TopCentre
-                }
-            };
-
-            Bindable.ValueChanged += delegate { updateFill(); };
-        }
-
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-            updateFill();
-        }
-
-        public double Volume
-        {
-            get => Bindable.Value;
-            private set => Bindable.Value = value;
-        }
-
-        public void Increase()
-        {
-            Volume += 0.05f;
-        }
-
-        public void Decrease()
-        {
-            Volume -= 0.05f;
-        }
-
-        private void updateFill() => meterFill.ScaleTo(new Vector2(1, (float)Volume), 300, Easing.OutQuint);
-
-        public bool OnPressed(GlobalAction action)
-        {
-            if (!IsHovered) return false;
-
-            switch (action)
-            {
-                case GlobalAction.DecreaseVolume:
-                    Decrease();
-                    return true;
-                case GlobalAction.IncreaseVolume:
-                    Increase();
-                    return true;
-            }
-
-            return false;
-        }
-
-        public bool OnReleased(GlobalAction action) => false;
-    }
-}

osu.Game/Online/API/APIAccess.cs

@@ -199,7 +199,7 @@ namespace osu.Game.Online.API
             }
             catch (WebException we)
             {
-                HttpStatusCode statusCode = (we.Response as HttpWebResponse)?.StatusCode ?? HttpStatusCode.RequestTimeout;
+                HttpStatusCode statusCode = (we.Response as HttpWebResponse)?.StatusCode ?? (we.Status == WebExceptionStatus.UnknownError ? HttpStatusCode.NotAcceptable : HttpStatusCode.RequestTimeout);
 
                 switch (statusCode)
                 {

osu.Game/OsuGame.cs

@@ -10,7 +10,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Overlays;
 using osu.Framework.Logging;
-using osu.Game.Graphics.UserInterface.Volume;
 using osu.Framework.Allocation;
 using osu.Game.Overlays.Toolbar;
 using osu.Game.Screens;
@@ -33,6 +32,7 @@ using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Skinning;
 using OpenTK.Graphics;
+using osu.Game.Overlays.Volume;
 
 namespace osu.Game
 {
@@ -75,7 +75,7 @@ namespace osu.Game
 
         private OsuScreen screenStack;
 
-        private VolumeControl volume;
+        private VolumeOverlay volume;
         private OnScreenDisplay onscreenDisplay;
 
         private Bindable<int> configRuleset;
@@ -238,7 +238,7 @@ namespace osu.Game
                 },
             }, overlayContent.Add);
 
-            loadComponentSingleFile(volume = new VolumeControl(), Add);
+            loadComponentSingleFile(volume = new VolumeOverlay(), overlayContent.Add);
             loadComponentSingleFile(onscreenDisplay = new OnScreenDisplay(), Add);
 
             //overlay elements

osu.Game/Overlays/Chat/ChatTabControl.cs

@@ -53,9 +53,9 @@ namespace osu.Game.Overlays.Chat
 
         protected override void AddTabItem(TabItem<Channel> item, bool addToDropdown = true)
         {
-            if (selectorTab.Depth < float.MaxValue)
+            if (item != selectorTab && TabContainer.GetLayoutPosition(selectorTab) < float.MaxValue)
                 // performTabSort might've made selectorTab's position wonky, fix it
-                TabContainer.ChangeChildDepth(selectorTab, float.MaxValue);
+                TabContainer.SetLayoutPosition(selectorTab, float.MaxValue);
 
             base.AddTabItem(item, addToDropdown);
 

osu.Game/Overlays/Music/PlaylistList.cs

@@ -101,11 +101,10 @@ namespace osu.Game.Overlays.Music
 
             public void AddBeatmapSet(BeatmapSetInfo beatmapSet)
             {
-                items.Add(new PlaylistItem(beatmapSet)
+                var newItem = new PlaylistItem(beatmapSet) { OnSelect = set => OnSelect?.Invoke(set) };
-                {
+
-                    OnSelect = set => OnSelect?.Invoke(set),
+                items.Add(newItem);
-                    Depth = items.Count
+                items.SetLayoutPosition(newItem, items.Count);
-                });
             }
 
             public void RemoveBeatmapSet(BeatmapSetInfo beatmapSet)
@@ -197,7 +196,7 @@ namespace osu.Game.Overlays.Music
             {
                 var itemsPos = items.ToLocalSpace(nativeDragPosition);
 
-                int srcIndex = (int)draggedItem.Depth;
+                int srcIndex = (int)items.GetLayoutPosition(draggedItem);
 
                 // Find the last item with position < mouse position. Note we can't directly use
                 // the item positions as they are being transformed
@@ -219,15 +218,15 @@ namespace osu.Game.Overlays.Music
                 if (srcIndex < dstIndex)
                 {
                     for (int i = srcIndex + 1; i <= dstIndex; i++)
-                        items.ChangeChildDepth(items[i], i - 1);
+                        items.SetLayoutPosition(items[i], i - 1);
                 }
                 else
                 {
                     for (int i = dstIndex; i < srcIndex; i++)
-                        items.ChangeChildDepth(items[i], i + 1);
+                        items.SetLayoutPosition(items[i], i + 1);
                 }
 
-                items.ChangeChildDepth(draggedItem, dstIndex);
+                items.SetLayoutPosition(draggedItem, dstIndex);
             }
 
             private class ItemSearchContainer : FillFlowContainer<PlaylistItem>, IHasFilterableChildren
@@ -243,9 +242,6 @@ namespace osu.Game.Overlays.Music
                     }
                 }
 
-                // Compare with reversed ChildID and Depth
-                protected override int Compare(Drawable x, Drawable y) => base.Compare(y, x);
-
                 public IEnumerable<IFilterable> FilterableChildren => Children;
 
                 public ItemSearchContainer()

osu.Game/Overlays/NotificationOverlay.cs

@@ -129,7 +129,6 @@ namespace osu.Game.Overlays
         public void Post(Notification notification) => postScheduler.Add(() =>
         {
             ++runningDepth;
-            notification.Depth = notification.DisplayOnTop ? runningDepth : -runningDepth;
 
             notification.Closed += notificationClosed;
 
@@ -138,7 +137,9 @@ namespace osu.Game.Overlays
                 hasCompletionTarget.CompletionTarget = Post;
 
             var ourType = notification.GetType();
-            sections.Children.FirstOrDefault(s => s.AcceptTypes.Any(accept => accept.IsAssignableFrom(ourType)))?.Add(notification);
+
+            var section = sections.Children.FirstOrDefault(s => s.AcceptTypes.Any(accept => accept.IsAssignableFrom(ourType)));
+            section?.Add(notification, notification.DisplayOnTop ? -runningDepth : runningDepth);
 
             updateCounts();
         });

osu.Game/Overlays/Notifications/NotificationSection.cs

@@ -25,10 +25,13 @@ namespace osu.Game.Overlays.Notifications
         private FlowContainer<Notification> notifications;
 
         public int DisplayedCount => notifications.Count(n => !n.WasClosed);
-
         public int UnreadCount => notifications.Count(n => !n.WasClosed && !n.Read);
 
-        public void Add(Notification notification) => notifications.Add(notification);
+        public void Add(Notification notification, float position)
+        {
+            notifications.Add(notification);
+            notifications.SetLayoutPosition(notification, position);
+        }
 
         public IEnumerable<Type> AcceptTypes;
 

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

@@ -40,16 +40,18 @@ namespace osu.Game.Overlays.Profile.Sections.Ranks
         [BackgroundDependencyLoader(true)]
         private void load(OsuColour colour)
         {
-            RightFlowContainer.Add(new OsuSpriteText
+            var text = new OsuSpriteText
             {
                 Text = $"accuracy: {Score.Accuracy:P2}",
                 Anchor = Anchor.TopRight,
                 Origin = Anchor.TopRight,
                 Colour = colour.GrayA,
                 TextSize = 11,
-                Font = "Exo2.0-RegularItalic",
+                Font = "Exo2.0-RegularItalic"
-                Depth = -1,
+            };
-            });
+
+            RightFlowContainer.Add(text);
+            RightFlowContainer.SetLayoutPosition(text, 1);
 
             LeftFlowContainer.Add(new BeatmapMetadataContainer(Score.Beatmap));
             LeftFlowContainer.Add(new OsuSpriteText

osu.Game/Overlays/Settings/SettingsItem.cs

@@ -45,7 +45,8 @@ namespace osu.Game.Overlays.Settings
                 if (text == null)
                 {
                     // construct lazily for cases where the label is not needed (may be provided by the Control).
-                    Add(text = new OsuSpriteText { Depth = 1 });
+                    Add(text = new OsuSpriteText());
+                    FlowContent.SetLayoutPosition(text, -1);
                 }
 
                 text.Text = value;

osu.Game/Overlays/Volume/MuteButton.cs

@@ -0,0 +1,83 @@
+// 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.Framework.Configuration;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Overlays.Volume
+{
+    public class MuteButton : Container, IHasCurrentValue<bool>
+    {
+        public Bindable<bool> Current { get; } = new Bindable<bool>();
+
+        private Color4 hoveredColour, unhoveredColour;
+        private const float width = 100;
+        public const float HEIGHT = 35;
+
+        public MuteButton()
+        {
+            Masking = true;
+            BorderThickness = 3;
+            CornerRadius = HEIGHT / 2;
+            Size = new Vector2(width, HEIGHT);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            hoveredColour = colours.YellowDark;
+            BorderColour = unhoveredColour = colours.Gray1.Opacity(0.9f);
+
+            SpriteIcon icon;
+            AddRange(new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = colours.Gray1,
+                    Alpha = 0.9f,
+                },
+                icon = new SpriteIcon
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.CentreLeft,
+                    Size = new Vector2(20),
+                }
+            });
+
+            Current.ValueChanged += newValue =>
+            {
+                icon.Icon = newValue ? FontAwesome.fa_volume_off : FontAwesome.fa_volume_up;
+                icon.Margin = new MarginPadding { Left = newValue ? width / 2 - 15 : width / 2 - 10 }; //Magic numbers to line up both icons because they're different widths
+            };
+            Current.TriggerChange();
+        }
+
+        protected override bool OnHover(InputState state)
+        {
+            this.TransformTo<MuteButton, SRGBColour>("BorderColour", hoveredColour, 500, Easing.OutQuint);
+            return true;
+        }
+
+        protected override void OnHoverLost(InputState state)
+        {
+            this.TransformTo<MuteButton, SRGBColour>("BorderColour", unhoveredColour, 500, Easing.OutQuint);
+        }
+
+        protected override bool OnClick(InputState state)
+        {
+            Current.Value = !Current.Value;
+            return true;
+        }
+    }
+}

osu.Game/Overlays/Volume/VolumeControlReceptor.cs

@@ -7,7 +7,7 @@ using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Game.Input.Bindings;
 
-namespace osu.Game.Graphics.UserInterface.Volume
+namespace osu.Game.Overlays.Volume
 {
     public class VolumeControlReceptor : Container, IKeyBindingHandler<GlobalAction>, IHandleGlobalInput
     {

osu.Game/Overlays/Volume/VolumeMeter.cs

@@ -0,0 +1,186 @@
+// 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.Globalization;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Effects;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.Bindings;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Input.Bindings;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Overlays.Volume
+{
+    public class VolumeMeter : Container, IKeyBindingHandler<GlobalAction>
+    {
+        private CircularProgress volumeCircle;
+        public BindableDouble Bindable { get; } = new BindableDouble { MinValue = 0, MaxValue = 1 };
+        private readonly float circleSize;
+        private readonly Color4 meterColour;
+        private readonly string name;
+
+        private OsuSpriteText text;
+        private BufferedContainer maxGlow;
+
+        public VolumeMeter(string name, float circleSize, Color4 meterColour)
+        {
+            this.circleSize = circleSize;
+            this.meterColour = meterColour;
+            this.name = name;
+
+            AutoSizeAxes = Axes.Both;
+        }
+
+        [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
+                    }
+                }
+            });
+
+            CircularProgress bgProgress;
+
+            Add(new CircularContainer
+            {
+                Masking = true,
+                Size = new Vector2(circleSize),
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        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)
+                    },
+                    (volumeCircle = new CircularProgress
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        InnerRadius = 0.05f,
+                        Rotation = 180,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Size = new Vector2(0.8f)
+                    }).WithEffect(new GlowEffect
+                    {
+                        Colour = meterColour,
+                        Strength = 2
+                    }),
+                    maxGlow = (text = new OsuSpriteText
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Font = "Venera",
+                        TextSize = 0.16f * circleSize
+                    }).WithEffect(new GlowEffect
+                    {
+                        Colour = Color4.Transparent,
+                        PadExtent = true,
+                    })
+                }
+            });
+
+            Bindable.ValueChanged += newVolume => { this.TransformTo("DisplayVolume", newVolume, 400, Easing.OutQuint); };
+            bgProgress.Current.Value = 0.75f;
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            Bindable.TriggerChange();
+        }
+
+        private double displayVolume;
+
+        protected double DisplayVolume
+        {
+            get => displayVolume;
+            set
+            {
+                displayVolume = value;
+
+                if (displayVolume > 0.99f)
+                {
+                    text.Text = "MAX";
+                    maxGlow.EffectColour = meterColour.Opacity(2f);
+                }
+                else
+                {
+                    maxGlow.EffectColour = Color4.Transparent;
+                    text.Text = Math.Round(displayVolume * 100).ToString(CultureInfo.CurrentCulture);
+                }
+
+                volumeCircle.Current.Value = displayVolume * 0.75f;
+            }
+        }
+
+        public double Volume
+        {
+            get => Bindable;
+            private set => Bindable.Value = value;
+        }
+
+        public void Increase() => Volume += 0.05f;
+
+        public void Decrease() => Volume -= 0.05f;
+
+        public bool OnPressed(GlobalAction action)
+        {
+            if (!IsHovered) return false;
+
+            switch (action)
+            {
+                case GlobalAction.DecreaseVolume:
+                    Decrease();
+                    return true;
+                case GlobalAction.IncreaseVolume:
+                    Increase();
+                    return true;
+            }
+
+            return false;
+        }
+
+        public bool OnReleased(GlobalAction action) => false;
+    }
+}

osu.Game/Overlays/VolumeOverlay.cs

@@ -1,57 +1,84 @@
 // 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.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Threading;
-using OpenTK;
-using osu.Framework.Audio;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
 using osu.Framework.Configuration;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Threading;
+using osu.Game.Graphics;
 using osu.Game.Input.Bindings;
+using osu.Game.Overlays.Volume;
+using OpenTK;
+using OpenTK.Graphics;
 
-namespace osu.Game.Graphics.UserInterface.Volume
+namespace osu.Game.Overlays
 {
-    public class VolumeControl : OverlayContainer
+    public class VolumeOverlay : OverlayContainer
     {
-        private readonly VolumeMeter volumeMeterMaster;
+        private const float offset = 10;
-        private readonly IconButton muteIcon;
+
+        private VolumeMeter volumeMeterMaster;
+        private VolumeMeter volumeMeterEffect;
+        private VolumeMeter volumeMeterMusic;
+        private MuteButton muteButton;
 
         protected override bool BlockPassThroughMouse => false;
 
-        public VolumeControl()
+        private readonly BindableDouble muteAdjustment = new BindableDouble();
-        {
-            AutoSizeAxes = Axes.Both;
-            Anchor = Anchor.BottomRight;
-            Origin = Anchor.BottomRight;
 
-            Children = new Drawable[]
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio, OsuColour colours)
+        {
+            AutoSizeAxes = Axes.X;
+            RelativeSizeAxes = Axes.Y;
+
+            AddRange(new Drawable[]
             {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Y,
+                    Width = 300,
+                    Colour = ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.75f), Color4.Black.Opacity(0))
+                },
                 new FillFlowContainer
                 {
+                    Direction = FillDirection.Vertical,
                     AutoSizeAxes = Axes.Both,
-                    Anchor = Anchor.BottomRight,
+                    Anchor = Anchor.CentreLeft,
-                    Origin = Anchor.BottomRight,
+                    Origin = Anchor.CentreLeft,
-                    Margin = new MarginPadding { Left = 10, Right = 10, Top = 30, Bottom = 30 },
+                    Spacing = new Vector2(0, offset),
-                    Spacing = new Vector2(15, 0),
+                    Margin = new MarginPadding { Left = offset },
                     Children = new Drawable[]
                     {
-                        new Container
+                        volumeMeterEffect = new VolumeMeter("EFFECTS", 125, colours.BlueDarker)
                         {
-                            Size = new Vector2(IconButton.BUTTON_SIZE),
+                            Margin = new MarginPadding { Top = 100 + MuteButton.HEIGHT } //to counter the mute button and re-center the volume meters
-                            Child = muteIcon = new IconButton
-                            {
-                                Anchor = Anchor.Centre,
-                                Origin = Anchor.Centre,
-                                Icon = FontAwesome.fa_volume_up,
-                                Action = () => Adjust(GlobalAction.ToggleMute),
-                            }
                         },
-                        volumeMeterMaster = new VolumeMeter("Master"),
+                        volumeMeterMaster = new VolumeMeter("MASTER", 150, colours.PinkDarker),
-                        volumeMeterEffect = new VolumeMeter("Effects"),
+                        volumeMeterMusic = new VolumeMeter("MUSIC", 125, colours.BlueDarker),
-                        volumeMeterMusic = new VolumeMeter("Music")
+                        muteButton = new MuteButton
+                        {
+                            Margin = new MarginPadding { Top = 100 }
+                        }
                     }
-                }
+                },
+            });
+
+            volumeMeterMaster.Bindable.BindTo(audio.Volume);
+            volumeMeterEffect.Bindable.BindTo(audio.VolumeSample);
+            volumeMeterMusic.Bindable.BindTo(audio.VolumeTrack);
+
+            muteButton.Current.ValueChanged += mute =>
+            {
+                if (mute)
+                    audio.AddAdjustment(AdjustableProperty.Volume, muteAdjustment);
+                else
+                    audio.RemoveAdjustment(AdjustableProperty.Volume, muteAdjustment);
             };
         }
 
@@ -62,7 +89,13 @@ namespace osu.Game.Graphics.UserInterface.Volume
             volumeMeterMaster.Bindable.ValueChanged += _ => settingChanged();
             volumeMeterEffect.Bindable.ValueChanged += _ => settingChanged();
             volumeMeterMusic.Bindable.ValueChanged += _ => settingChanged();
-            muted.ValueChanged += _ => settingChanged();
+            muteButton.Current.ValueChanged += _ => settingChanged();
+        }
+
+        private void settingChanged()
+        {
+            Show();
+            schedulePopOut();
         }
 
         public bool Adjust(GlobalAction action)
@@ -83,50 +116,15 @@ namespace osu.Game.Graphics.UserInterface.Volume
                     return true;
                 case GlobalAction.ToggleMute:
                     Show();
-                    muted.Toggle();
+                    muteButton.Current.Value = !muteButton.Current;
                     return true;
             }
 
             return false;
         }
 
-        private void settingChanged()
-        {
-            Show();
-            schedulePopOut();
-        }
-
-        private readonly BindableDouble muteAdjustment = new BindableDouble();
-
-        private readonly BindableBool muted = new BindableBool();
-
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
-        {
-            volumeMeterMaster.Bindable.BindTo(audio.Volume);
-            volumeMeterEffect.Bindable.BindTo(audio.VolumeSample);
-            volumeMeterMusic.Bindable.BindTo(audio.VolumeTrack);
-
-            muted.ValueChanged += mute =>
-            {
-                if (mute)
-                {
-                    audio.AddAdjustment(AdjustableProperty.Volume, muteAdjustment);
-                    muteIcon.Icon = FontAwesome.fa_volume_off;
-                }
-                else
-                {
-                    audio.RemoveAdjustment(AdjustableProperty.Volume, muteAdjustment);
-                    muteIcon.Icon = FontAwesome.fa_volume_up;
-                }
-            };
-        }
-
         private ScheduledDelegate popOutDelegate;
 
-        private readonly VolumeMeter volumeMeterEffect;
-        private readonly VolumeMeter volumeMeterMusic;
-
         protected override void PopIn()
         {
             ClearTransforms();

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

@@ -35,8 +35,9 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         protected virtual IEnumerable<SampleInfo> GetSamples() => HitObject.Samples;
 
-        private List<DrawableHitObject> nestedHitObjects;
+        private readonly Lazy<List<DrawableHitObject>> nestedHitObjects = new Lazy<List<DrawableHitObject>>();
-        public IReadOnlyList<DrawableHitObject> NestedHitObjects => nestedHitObjects;
+        public bool HasNestedHitObjects => nestedHitObjects.IsValueCreated;
+        public IReadOnlyList<DrawableHitObject> NestedHitObjects => nestedHitObjects.Value;
 
         public event Action<DrawableHitObject, Judgement> OnJudgement;
         public event Action<DrawableHitObject, Judgement> OnJudgementRemoved;
@@ -52,12 +53,12 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// <summary>
         /// Whether this <see cref="DrawableHitObject"/> and all of its nested <see cref="DrawableHitObject"/>s have been hit.
         /// </summary>
-        public bool IsHit => Judgements.Any(j => j.Final && j.IsHit) && (NestedHitObjects?.All(n => n.IsHit) ?? true);
+        public bool IsHit => Judgements.Any(j => j.Final && j.IsHit) && (!HasNestedHitObjects || NestedHitObjects.All(n => n.IsHit));
 
         /// <summary>
         /// Whether this <see cref="DrawableHitObject"/> and all of its nested <see cref="DrawableHitObject"/>s have been judged.
         /// </summary>
-        public bool AllJudged => (!ProvidesJudgement || judgementFinalized) && (NestedHitObjects?.All(h => h.AllJudged) ?? true);
+        public bool AllJudged => (!ProvidesJudgement || judgementFinalized) && (!HasNestedHitObjects || NestedHitObjects.All(h => h.AllJudged));
 
         /// <summary>
         /// Whether this <see cref="DrawableHitObject"/> can be judged.
@@ -160,14 +161,11 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         protected virtual void AddNested(DrawableHitObject h)
         {
-            if (nestedHitObjects == null)
-                nestedHitObjects = new List<DrawableHitObject>();
-
             h.OnJudgement += (d, j) => OnJudgement?.Invoke(d, j);
             h.OnJudgementRemoved += (d, j) => OnJudgementRemoved?.Invoke(d, j);
             h.ApplyCustomUpdateState += (d, j) => ApplyCustomUpdateState?.Invoke(d, j);
 
-            nestedHitObjects.Add(h);
+            nestedHitObjects.Value.Add(h);
         }
 
         /// <summary>
@@ -211,7 +209,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
             if (AllJudged)
                 return false;
 
-            if (NestedHitObjects != null)
+            if (HasNestedHitObjects)
                 foreach (var d in NestedHitObjects)
                     judgementOccurred |= d.UpdateJudgement(userTriggered);
 

osu.Game/Rulesets/Ruleset.cs

@@ -64,7 +64,7 @@ namespace osu.Game.Rulesets
         /// <summary>
         /// Do not override this unless you are a legacy mode.
         /// </summary>
-        public virtual int LegacyID => -1;
+        public virtual int? LegacyID => null;
 
         /// <summary>
         /// A unique short name to reference this ruleset in online requests.

osu.Game/Rulesets/UI/RulesetInputManager.cs

@@ -91,8 +91,6 @@ namespace osu.Game.Rulesets.UI
 
         #region Clock control
 
-        protected override bool ShouldProcessClock => false; // We handle processing the clock ourselves
-
         private ManualClock clock;
         private IFrameBasedClock parentClock;
 
@@ -103,6 +101,7 @@ namespace osu.Game.Rulesets.UI
             //our clock will now be our parent's clock, but we want to replace this to allow manual control.
             parentClock = Clock;
 
+            ProcessCustomClock = false;
             Clock = new FramedClock(clock = new ManualClock
             {
                 CurrentTime = parentClock.CurrentTime,

osu.Game/Rulesets/UI/Scrolling/Visualisers/OverlappingSpeedChangeVisualiser.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.UI.Scrolling.Visualisers
                 var controlPoint = controlPointAt(obj.HitObject.StartTime);
                 obj.LifetimeStart = obj.HitObject.StartTime - timeRange / controlPoint.Multiplier;
 
-                if (obj.NestedHitObjects != null)
+                if (obj.HasNestedHitObjects)
                 {
                     ComputeInitialStates(obj.NestedHitObjects, direction, timeRange, length);
                     ComputePositions(obj.NestedHitObjects, direction, obj.HitObject.StartTime, timeRange, length);

osu.Game/Rulesets/UI/Scrolling/Visualisers/SequentialSpeedChangeVisualiser.cs

@@ -46,7 +46,7 @@ namespace osu.Game.Rulesets.UI.Scrolling.Visualisers
                     }
                 }
 
-                if (obj.NestedHitObjects != null)
+                if (obj.HasNestedHitObjects)
                 {
                     ComputeInitialStates(obj.NestedHitObjects, direction, timeRange, length);
                     ComputePositions(obj.NestedHitObjects, direction, obj.HitObject.StartTime, timeRange, length);

osu.Game/Screens/Menu/FlowContainerWithOrigin.cs

@@ -4,8 +4,6 @@
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using OpenTK;
-using System.Collections.Generic;
-using System.Linq;
 
 namespace osu.Game.Screens.Menu
 {
@@ -22,8 +20,6 @@ namespace osu.Game.Screens.Menu
 
         protected override int Compare(Drawable x, Drawable y) => CompareReverseChildID(x, y);
 
-        protected override IEnumerable<Drawable> FlowingChildren => base.FlowingChildren.Reverse();
-
         public override Anchor Origin => Anchor.Custom;
 
         public override Vector2 OriginPosition

osu.Game/Screens/Play/HUDOverlay.cs

@@ -41,7 +41,7 @@ namespace osu.Game.Screens.Play
 
         private static bool hasShownNotificationOnce;
 
-        public HUDOverlay(ScoreProcessor scoreProcessor, RulesetContainer rulesetContainer, DecoupleableInterpolatingFramedClock decoupledClock, WorkingBeatmap working, IAdjustableClock adjustableSourceClock)
+        public HUDOverlay(ScoreProcessor scoreProcessor, RulesetContainer rulesetContainer, WorkingBeatmap working, IClock offsetClock, IAdjustableClock adjustableClock)
         {
             RelativeSizeAxes = Axes.Both;
 
@@ -66,13 +66,13 @@ namespace osu.Game.Screens.Play
             BindRulesetContainer(rulesetContainer);
 
             Progress.Objects = rulesetContainer.Objects;
-            Progress.AudioClock = decoupledClock;
+            Progress.AudioClock = offsetClock;
             Progress.AllowSeeking = rulesetContainer.HasReplayLoaded;
-            Progress.OnSeek = pos => decoupledClock.Seek(pos);
+            Progress.OnSeek = pos => adjustableClock.Seek(pos);
 
             ModDisplay.Current.BindTo(working.Mods);
 
-            PlayerSettingsOverlay.PlaybackSettings.AdjustableClock = adjustableSourceClock;
+            PlayerSettingsOverlay.PlaybackSettings.AdjustableClock = adjustableClock;
         }
 
         [BackgroundDependencyLoader(true)]

osu.Game/Screens/Play/PauseContainer.cs

@@ -44,14 +44,22 @@ namespace osu.Game.Screens.Play
         public Action OnResume;
         public Action OnPause;
 
-        public IAdjustableClock AudioClock;
+        private readonly IAdjustableClock adjustableClock;
-        public FramedClock FramedClock;
+        private readonly FramedClock framedClock;
 
-        public PauseContainer()
+        public PauseContainer(FramedClock framedClock, IAdjustableClock adjustableClock)
         {
+            this.framedClock = framedClock;
+            this.adjustableClock = adjustableClock;
+
             RelativeSizeAxes = Axes.Both;
 
-            AddInternal(content = new Container { RelativeSizeAxes = Axes.Both });
+            AddInternal(content = new Container
+            {
+                Clock = this.framedClock,
+                ProcessCustomClock = false,
+                RelativeSizeAxes = Axes.Both
+            });
 
             AddInternal(pauseOverlay = new PauseOverlay
             {
@@ -65,47 +73,37 @@ namespace osu.Game.Screens.Play
             });
         }
 
-        public void Pause(bool force = false)
+        public void Pause(bool force = false) => Schedule(() => // Scheduled to ensure a stable position in execution order, no matter how it was called.
         {
             if (!CanPause && !force) return;
 
             if (IsPaused) return;
 
-            // stop the decoupled clock (stops the audio eventually)
+            // stop the seekable clock (stops the audio eventually)
-            AudioClock.Stop();
+            adjustableClock.Stop();
-
-            // stop processing updatess on the offset clock (instantly freezes time for all our components)
-            FramedClock.ProcessSourceClockFrames = false;
-
             IsPaused = true;
 
-            // we need to do a final check after all of our children have processed up to the paused clock time.
+            OnPause?.Invoke();
-            // this is to cover cases where, for instance, the player fails in the current processing frame.
+            pauseOverlay.Show();
-            Schedule(() =>
-            {
-                if (!CanPause) return;
 
-                lastPauseActionTime = Time.Current;
+            lastPauseActionTime = Time.Current;
-
+        });
-                OnPause?.Invoke();
-                pauseOverlay.Show();
-            });
-        }
 
         public void Resume()
         {
             if (!IsPaused) return;
 
             IsPaused = false;
-            FramedClock.ProcessSourceClockFrames = true;
+            IsResuming = false;
-
             lastPauseActionTime = Time.Current;
 
-            OnResume?.Invoke();
+            // seek back to the time of the framed clock.
+            // this accounts for the audio clock potentially taking time to enter a completely stopped state.
+            adjustableClock.Seek(framedClock.CurrentTime);
+            adjustableClock.Start();
 
+            OnResume?.Invoke();
             pauseOverlay.Hide();
-            AudioClock.Start();
-            IsResuming = false;
         }
 
         private OsuGameBase game;
@@ -122,6 +120,9 @@ namespace osu.Game.Screens.Play
             if (!game.IsActive && CanPause)
                 Pause();
 
+            if (!IsPaused)
+                framedClock.ProcessFrame();
+
             base.Update();
         }
 

osu.Game/Screens/Play/Player.cs

@@ -56,9 +56,12 @@ namespace osu.Game.Screens.Play
         public CursorContainer Cursor => RulesetContainer.Cursor;
         public bool ProvidingUserCursor => RulesetContainer?.Cursor != null && !RulesetContainer.HasReplayLoaded.Value;
 
-        private IAdjustableClock adjustableSourceClock;
+        private IAdjustableClock sourceClock;
-        private FramedOffsetClock offsetClock;
+
-        private DecoupleableInterpolatingFramedClock decoupledClock;
+        /// <summary>
+        /// The decoupled clock used for gameplay. Should be used for seeks and clock control.
+        /// </summary>
+        private DecoupleableInterpolatingFramedClock adjustableClock;
 
         private PauseContainer pauseContainer;
 
@@ -140,17 +143,18 @@ namespace osu.Game.Screens.Play
                 return;
             }
 
-            adjustableSourceClock = (IAdjustableClock)working.Track ?? new StopwatchClock();
+            sourceClock = (IAdjustableClock)working.Track ?? new StopwatchClock();
-            decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+            adjustableClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
 
             var firstObjectTime = RulesetContainer.Objects.First().StartTime;
-            decoupledClock.Seek(AllowLeadIn
+            adjustableClock.Seek(AllowLeadIn
                 ? Math.Min(0, firstObjectTime - Math.Max(beatmap.ControlPointInfo.TimingPointAt(firstObjectTime).BeatLength * 4, beatmap.BeatmapInfo.AudioLeadIn))
                 : firstObjectTime);
 
-            decoupledClock.ProcessFrame();
+            adjustableClock.ProcessFrame();
 
-            offsetClock = new FramedOffsetClock(decoupledClock);
+            // the final usable gameplay clock with user-set offsets applied.
+            var offsetClock = new FramedOffsetClock(adjustableClock);
 
             userAudioOffset = config.GetBindable<double>(OsuSetting.AudioOffset);
             userAudioOffset.ValueChanged += v => offsetClock.Offset = v;
@@ -160,16 +164,8 @@ namespace osu.Game.Screens.Play
 
             Children = new Drawable[]
             {
-                storyboardContainer = new Container
+                pauseContainer = new PauseContainer(offsetClock, adjustableClock)
                 {
-                    RelativeSizeAxes = Axes.Both,
-                    Clock = offsetClock,
-                    Alpha = 0,
-                },
-                pauseContainer = new PauseContainer
-                {
-                    AudioClock = decoupledClock,
-                    FramedClock = offsetClock,
                     OnRetry = Restart,
                     OnQuit = Exit,
                     CheckCanPause = () => AllowPause && ValidForResume && !HasFailed && !RulesetContainer.HasReplayLoaded,
@@ -181,15 +177,23 @@ namespace osu.Game.Screens.Play
                     OnResume = () => hudOverlay.KeyCounter.IsCounting = true,
                     Children = new Drawable[]
                     {
-                        new Container
+                        storyboardContainer = new Container
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Clock = offsetClock,
+                            Alpha = 0,
-                            Child = RulesetContainer,
                         },
-                        new SkipButton(firstObjectTime) { AudioClock = decoupledClock },
+                        RulesetContainer,
-                        hudOverlay = new HUDOverlay(scoreProcessor, RulesetContainer, decoupledClock, working, adjustableSourceClock)
+                        new SkipButton(firstObjectTime)
                         {
+                            Clock = Clock, // skip button doesn't want to use the audio clock directly
+                            ProcessCustomClock = false,
+                            AdjustableClock = adjustableClock,
+                            FramedClock = offsetClock,
+                        },
+                        hudOverlay = new HUDOverlay(scoreProcessor, RulesetContainer, working, offsetClock, adjustableClock)
+                        {
+                            Clock = Clock, // hud overlay doesn't want to use the audio clock directly
+                            ProcessCustomClock = false,
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre
                         },
@@ -197,7 +201,7 @@ namespace osu.Game.Screens.Play
                         {
                             Anchor = Anchor.Centre,
                             Origin = Anchor.Centre,
-                            Clock = decoupledClock,
+                            ProcessCustomClock = false,
                             Breaks = beatmap.Breaks
                         }
                     }
@@ -234,11 +238,11 @@ namespace osu.Game.Screens.Play
 
         private void applyRateFromMods()
         {
-            if (adjustableSourceClock == null) return;
+            if (sourceClock == null) return;
 
-            adjustableSourceClock.Rate = 1;
+            sourceClock.Rate = 1;
             foreach (var mod in Beatmap.Value.Mods.Value.OfType<IApplicableToClock>())
-                mod.ApplyToClock(adjustableSourceClock);
+                mod.ApplyToClock(sourceClock);
         }
 
         private void initializeStoryboard(bool asyncLoad)
@@ -297,7 +301,7 @@ namespace osu.Game.Screens.Play
             if (Beatmap.Value.Mods.Value.OfType<IApplicableFailOverride>().Any(m => !m.AllowFail))
                 return false;
 
-            decoupledClock.Stop();
+            adjustableClock.Stop();
 
             HasFailed = true;
             failOverlay.Retries = RestartCount;
@@ -326,17 +330,19 @@ namespace osu.Game.Screens.Play
 
             Task.Run(() =>
             {
-                adjustableSourceClock.Reset();
+                sourceClock.Reset();
 
                 Schedule(() =>
                 {
-                    decoupledClock.ChangeSource(adjustableSourceClock);
+                    adjustableClock.ChangeSource(sourceClock);
                     applyRateFromMods();
 
                     this.Delay(750).Schedule(() =>
                     {
                         if (!pauseContainer.IsPaused)
-                            decoupledClock.Start();
+                        {
+                            adjustableClock.Start();
+                        }
                     });
                 });
             });
@@ -363,9 +369,7 @@ namespace osu.Game.Screens.Play
             }
 
             if (loadedSuccessfully)
-            {
                 pauseContainer?.Pause();
-            }
 
             return true;
         }

osu.Game/Screens/Play/SkipButton.cs

@@ -24,7 +24,9 @@ namespace osu.Game.Screens.Play
     public class SkipButton : OverlayContainer, IKeyBindingHandler<GlobalAction>
     {
         private readonly double startTime;
-        public IAdjustableClock AudioClock;
+
+        public IAdjustableClock AdjustableClock;
+        public IFrameBasedClock FramedClock;
 
         private Button button;
         private Box remainingTimeBox;
@@ -60,8 +62,11 @@ namespace osu.Game.Screens.Play
         {
             var baseClock = Clock;
 
-            if (AudioClock != null)
+            if (FramedClock != null)
-                Clock = new FramedClock(AudioClock) { ProcessSourceClockFrames = false };
+            {
+                Clock = FramedClock;
+                ProcessCustomClock = false;
+            }
 
             Children = new Drawable[]
             {
@@ -109,7 +114,7 @@ namespace osu.Game.Screens.Play
             using (BeginAbsoluteSequence(beginFadeTime))
                 this.FadeOut(fade_time);
 
-            button.Action = () => AudioClock?.Seek(startTime - skip_required_cutoff - fade_time);
+            button.Action = () => AdjustableClock?.Seek(startTime - skip_required_cutoff - fade_time);
 
             displayTime = Time.Current;
 

osu.Game/Screens/Select/Footer.cs

@@ -41,19 +41,25 @@ namespace osu.Game.Screens.Select
         /// <para>Higher depth to be put on the left, and lower to be put on the right.</para>
         /// <para>Notice this is different to <see cref="Options.BeatmapOptionsOverlay"/>!</para>
         /// </param>
-        public void AddButton(string text, Color4 colour, Action action, Key? hotkey = null, float depth = 0) => buttons.Add(new FooterButton
+        public void AddButton(string text, Color4 colour, Action action, Key? hotkey = null, float depth = 0)
         {
-            Text = text,
+            var button = new FooterButton
-            Height = play_song_select_button_height,
+            {
-            Width = play_song_select_button_width,
+                Text = text,
-            Depth = depth,
+                Height = play_song_select_button_height,
-            SelectedColour = colour,
+                Width = play_song_select_button_width,
-            DeselectedColour = colour.Opacity(0.5f),
+                Depth = depth,
-            Hotkey = hotkey,
+                SelectedColour = colour,
-            Hovered = updateModeLight,
+                DeselectedColour = colour.Opacity(0.5f),
-            HoverLost = updateModeLight,
+                Hotkey = hotkey,
-            Action = action,
+                Hovered = updateModeLight,
-        });
+                HoverLost = updateModeLight,
+                Action = action,
+            };
+
+            buttons.Add(button);
+            buttons.SetLayoutPosition(button, -depth);
+        }
 
         private readonly List<OverlayContainer> overlays = new List<OverlayContainer>();
 

osu.Game/Screens/Select/Options/BeatmapOptionsOverlay.cs

@@ -95,7 +95,7 @@ namespace osu.Game.Screens.Select.Options
         /// </param>
         public void AddButton(string firstLine, string secondLine, FontAwesome icon, Color4 colour, Action action, Key? hotkey = null, float depth = 0)
         {
-            buttonsContainer.Add(new BeatmapOptionsButton
+            var button = new BeatmapOptionsButton
             {
                 FirstLineText = firstLine,
                 SecondLineText = secondLine,
@@ -108,7 +108,10 @@ namespace osu.Game.Screens.Select.Options
                     action?.Invoke();
                 },
                 HotKey = hotkey
-            });
+            };
+
+            buttonsContainer.Add(button);
+            buttonsContainer.SetLayoutPosition(button, depth);
         }
     }
 }

osu.Game/Skinning/LegacySkin.cs

@@ -22,16 +22,14 @@ namespace osu.Game.Skinning
         public LegacySkin(SkinInfo skin, IResourceStore<byte[]> storage, AudioManager audioManager)
             : base(skin)
         {
+            storage = new LegacySkinResourceStore(skin, storage);
             samples = audioManager.GetSampleManager(storage);
             textures = new TextureStore(new RawTextureLoaderStore(storage));
         }
 
-        private string getPathForFile(string filename) =>
-            SkinInfo.Files.FirstOrDefault(f => string.Equals(Path.GetFileNameWithoutExtension(f.Filename), filename, StringComparison.InvariantCultureIgnoreCase))?.FileInfo.StoragePath;
-
         public override Drawable GetDrawableComponent(string componentName)
         {
-            var texture = textures.Get(getPathForFile(componentName.Split('/').Last()));
+            var texture = textures.Get(componentName);
             if (texture == null) return null;
 
             return new Sprite
@@ -42,6 +40,25 @@ namespace osu.Game.Skinning
             };
         }
 
-        public override SampleChannel GetSample(string sampleName) => samples.Get(getPathForFile(sampleName.Split('/').Last()));
+        public override SampleChannel GetSample(string sampleName) => samples.Get(sampleName);
+
+        private class LegacySkinResourceStore : IResourceStore<byte[]>
+        {
+            private readonly SkinInfo skin;
+            private readonly IResourceStore<byte[]> underlyingStore;
+
+            private string getPathForFile(string filename) =>
+                skin.Files.FirstOrDefault(f => string.Equals(Path.GetFileNameWithoutExtension(f.Filename), filename.Split('/').Last(), StringComparison.InvariantCultureIgnoreCase))?.FileInfo.StoragePath;
+
+            public LegacySkinResourceStore(SkinInfo skin, IResourceStore<byte[]> underlyingStore)
+            {
+                this.skin = skin;
+                this.underlyingStore = underlyingStore;
+            }
+
+            public Stream GetStream(string name) => underlyingStore.GetStream(getPathForFile(name));
+
+            byte[] IResourceStore<byte[]>.Get(string name) => underlyingStore.Get(getPathForFile(name));
+        }
     }
 }

osu.Game/Storyboards/Drawables/DrawableStoryboard.cs

@@ -33,6 +33,8 @@ namespace osu.Game.Storyboards.Drawables
             }
         }
 
+        public override bool RemoveCompletedTransforms => false;
+
         private DependencyContainer dependencies;
         protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent) =>
             dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));

osu.Game/Storyboards/Drawables/DrawableStoryboardAnimation.cs

@@ -17,6 +17,8 @@ namespace osu.Game.Storyboards.Drawables
         public bool FlipH { get; set; }
         public bool FlipV { get; set; }
 
+        public override bool RemoveWhenNotAlive => false;
+
         protected override Vector2 DrawScale
             => new Vector2(FlipH ? -base.DrawScale.X : base.DrawScale.X, FlipV ? -base.DrawScale.Y : base.DrawScale.Y);
 

osu.Game/Storyboards/Drawables/DrawableStoryboardSprite.cs

@@ -17,6 +17,8 @@ namespace osu.Game.Storyboards.Drawables
         public bool FlipH { get; set; }
         public bool FlipV { get; set; }
 
+        public override bool RemoveWhenNotAlive => false;
+
         protected override Vector2 DrawScale
             => new Vector2(FlipH ? -base.DrawScale.X : base.DrawScale.X, FlipV ? -base.DrawScale.Y : base.DrawScale.Y);
 

osu.Game/Tests/Beatmaps/BeatmapConversionTest.cs

@@ -109,10 +109,13 @@ namespace osu.Game.Tests.Beatmaps
 
         private Beatmap getBeatmap(string name)
         {
-            var decoder = new LegacyBeatmapDecoder();
             using (var resStream = openResource($"{resource_namespace}.{name}.osu"))
             using (var stream = new StreamReader(resStream))
+            {
+                var decoder = Decoder.GetDecoder(stream);
+                ((LegacyBeatmapDecoder)decoder).ApplyOffsets = false;
                 return decoder.DecodeBeatmap(stream);
+            }
         }
 
         private Stream openResource(string name)

osu.Game/osu.Game.csproj

@@ -355,6 +355,10 @@
     <Compile Include="Overlays\Profile\Sections\Ranks\ScoreModsContainer.cs" />
     <Compile Include="Overlays\Settings\Sections\Gameplay\ScrollingSettings.cs" />
     <Compile Include="Overlays\Settings\Sections\Maintenance\DeleteAllBeatmapsDialog.cs" />
+    <Compile Include="Overlays\VolumeOverlay.cs" />
+    <Compile Include="Overlays\Volume\MuteButton.cs" />
+    <Compile Include="Overlays\Volume\VolumeControlReceptor.cs" />
+    <Compile Include="Overlays\Volume\VolumeMeter.cs" />
     <Compile Include="Rulesets\Configuration\IRulesetConfigManager.cs" />
     <Compile Include="Rulesets\Configuration\RulesetConfigManager.cs" />
     <Compile Include="Rulesets\Edit\Layers\BorderLayer.cs" />
@@ -478,9 +482,6 @@
     <Compile Include="Graphics\UserInterface\SimpleComboCounter.cs" />
     <Compile Include="Graphics\UserInterface\StarCounter.cs" />
     <Compile Include="Graphics\UserInterface\TwoLayerButton.cs" />
-    <Compile Include="Graphics\UserInterface\Volume\VolumeControl.cs" />
-    <Compile Include="Graphics\UserInterface\Volume\VolumeControlReceptor.cs" />
-    <Compile Include="Graphics\UserInterface\Volume\VolumeMeter.cs" />
     <Compile Include="Input\Bindings\DatabasedKeyBinding.cs" />
     <Compile Include="Input\Bindings\DatabasedKeyBindingContainer.cs" />
     <Compile Include="Input\Bindings\GlobalActionContainer.cs" />