Merge branch 'master' into fix-crash-hidden-sets#2

osu-framework

@@ -1 +1 @@
-Subproject commit 8c16e6244d8ca884a743a0d5a1f1ee485f18655c
+Subproject commit 00740e0185b9d828b67d6228d8e5d5bf0d49af94

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -1,6 +1,7 @@
 // Copyright (c) 2007-2017 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.ComponentModel;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.UI;
@@ -9,6 +10,8 @@ namespace osu.Game.Rulesets.Osu
 {
     public class OsuInputManager : RulesetInputManager<OsuAction>
     {
+        public IEnumerable<OsuAction> PressedActions => KeyBindingContainer.PressedActions;
+
         public OsuInputManager(RulesetInfo ruleset) : base(ruleset, 0, SimultaneousBindingMode.Unique)
         {
         }

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

@@ -0,0 +1,214 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.IO;
+using NUnit.Framework;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Game.Tests.Resources;
+using System.Linq;
+using osu.Game.Audio;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Beatmaps.Formats;
+using osu.Game.Beatmaps.Timing;
+
+namespace osu.Game.Tests.Beatmaps.Formats
+{
+    [TestFixture]
+    public class LegacyBeatmapDecoderTest
+    {
+        [Test]
+        public void TestDecodeBeatmapGeneral()
+        {
+            var decoder = new LegacyBeatmapDecoder();
+            using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var beatmap = decoder.DecodeBeatmap(stream);
+                var beatmapInfo = beatmap.BeatmapInfo;
+                var metadata = beatmap.Metadata;
+
+                Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", metadata.AudioFile);
+                Assert.AreEqual(0, beatmapInfo.AudioLeadIn);
+                Assert.AreEqual(164471, metadata.PreviewTime);
+                Assert.IsFalse(beatmapInfo.Countdown);
+                Assert.AreEqual(0.7f, beatmapInfo.StackLeniency);
+                Assert.IsTrue(beatmapInfo.RulesetID == 0);
+                Assert.IsFalse(beatmapInfo.LetterboxInBreaks);
+                Assert.IsFalse(beatmapInfo.SpecialStyle);
+                Assert.IsFalse(beatmapInfo.WidescreenStoryboard);
+            }
+        }
+
+        [Test]
+        public void TestDecodeBeatmapEditor()
+        {
+            var decoder = new LegacyBeatmapDecoder();
+            using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var beatmapInfo = decoder.DecodeBeatmap(stream).BeatmapInfo;
+
+                int[] expectedBookmarks =
+                {
+                    11505, 22054, 32604, 43153, 53703, 64252, 74802, 85351,
+                    95901, 106450, 116999, 119637, 130186, 140735, 151285,
+                    161834, 164471, 175020, 185570, 196119, 206669, 209306
+                };
+                Assert.AreEqual(expectedBookmarks.Length, beatmapInfo.Bookmarks.Length);
+                for (int i = 0; i < expectedBookmarks.Length; i++)
+                    Assert.AreEqual(expectedBookmarks[i], beatmapInfo.Bookmarks[i]);
+                Assert.AreEqual(1.8, beatmapInfo.DistanceSpacing);
+                Assert.AreEqual(4, beatmapInfo.BeatDivisor);
+                Assert.AreEqual(4, beatmapInfo.GridSize);
+                Assert.AreEqual(2, beatmapInfo.TimelineZoom);
+            }
+        }
+
+        [Test]
+        public void TestDecodeBeatmapMetadata()
+        {
+            var decoder = new LegacyBeatmapDecoder();
+            using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var beatmap = decoder.DecodeBeatmap(stream);
+                var beatmapInfo = beatmap.BeatmapInfo;
+                var metadata = beatmap.Metadata;
+
+                Assert.AreEqual("Renatus", metadata.Title);
+                Assert.AreEqual("Renatus", metadata.TitleUnicode);
+                Assert.AreEqual("Soleily", metadata.Artist);
+                Assert.AreEqual("Soleily", metadata.ArtistUnicode);
+                Assert.AreEqual("Gamu", metadata.AuthorString);
+                Assert.AreEqual("Insane", beatmapInfo.Version);
+                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);
+            }
+        }
+
+        [Test]
+        public void TestDecodeBeatmapDifficulty()
+        {
+            var decoder = new LegacyBeatmapDecoder();
+            using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var difficulty = decoder.DecodeBeatmap(stream).BeatmapInfo.BaseDifficulty;
+
+                Assert.AreEqual(6.5f, difficulty.DrainRate);
+                Assert.AreEqual(4, difficulty.CircleSize);
+                Assert.AreEqual(8, difficulty.OverallDifficulty);
+                Assert.AreEqual(9, difficulty.ApproachRate);
+                Assert.AreEqual(1.8f, difficulty.SliderMultiplier);
+                Assert.AreEqual(2, difficulty.SliderTickRate);
+            }
+        }
+
+        [Test]
+        public void TestDecodeBeatmapEvents()
+        {
+            var decoder = new LegacyBeatmapDecoder();
+            using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var beatmap = decoder.DecodeBeatmap(stream);
+                var metadata = beatmap.Metadata;
+                var breakPoint = beatmap.Breaks[0];
+
+                Assert.AreEqual("machinetop_background.jpg", metadata.BackgroundFile);
+                Assert.AreEqual(122474, breakPoint.StartTime);
+                Assert.AreEqual(140135, breakPoint.EndTime);
+                Assert.IsTrue(breakPoint.HasEffect);
+            }
+        }
+
+        [Test]
+        public void TestDecodeBeatmapTimingPoints()
+        {
+            var decoder = new LegacyBeatmapDecoder();
+            using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var beatmap = decoder.DecodeBeatmap(stream);
+                var controlPoints = beatmap.ControlPointInfo;
+
+                Assert.AreEqual(4, controlPoints.TimingPoints.Count);
+                var timingPoint = controlPoints.TimingPoints[0];
+                Assert.AreEqual(956, timingPoint.Time);
+                Assert.AreEqual(329.67032967033d, timingPoint.BeatLength);
+                Assert.AreEqual(TimeSignatures.SimpleQuadruple, timingPoint.TimeSignature);
+
+                Assert.AreEqual(5, controlPoints.DifficultyPoints.Count);
+                var difficultyPoint = controlPoints.DifficultyPoints[0];
+                Assert.AreEqual(116999, difficultyPoint.Time);
+                Assert.AreEqual(0.75000000000000189d, difficultyPoint.SpeedMultiplier);
+
+                Assert.AreEqual(34, controlPoints.SoundPoints.Count);
+                var soundPoint = controlPoints.SoundPoints[0];
+                Assert.AreEqual(956, soundPoint.Time);
+                Assert.AreEqual("soft", soundPoint.SampleBank);
+                Assert.AreEqual(60, soundPoint.SampleVolume);
+
+                Assert.AreEqual(8, controlPoints.EffectPoints.Count);
+                var effectPoint = controlPoints.EffectPoints[0];
+                Assert.AreEqual(53703, effectPoint.Time);
+                Assert.IsTrue(effectPoint.KiaiMode);
+                Assert.IsFalse(effectPoint.OmitFirstBarLine);
+            }
+        }
+
+        [Test]
+        public void TestDecodeBeatmapColors()
+        {
+            var decoder = new LegacyBeatmapDecoder();
+            using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var comboColors = decoder.DecodeBeatmap(stream).ComboColors;
+
+                Color4[] expectedColors =
+                {
+                    new Color4(142, 199, 255, 255),
+                    new Color4(255, 128, 128, 255),
+                    new Color4(128, 255, 255, 255),
+                    new Color4(128, 255, 128, 255),
+                    new Color4(255, 187, 255, 255),
+                    new Color4(255, 177, 140, 255),
+                };
+                Assert.AreEqual(expectedColors.Length, comboColors.Count);
+                for (int i = 0; i < expectedColors.Length; i++)
+                    Assert.AreEqual(expectedColors[i], comboColors[i]);
+            }
+        }
+
+        [Test]
+        public void TestDecodeBeatmapHitObjects()
+        {
+            var decoder = new LegacyBeatmapDecoder();
+            using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var hitObjects = decoder.DecodeBeatmap(stream).HitObjects;
+
+                var curveData = hitObjects[0] as IHasCurve;
+                var positionData = hitObjects[0] as IHasPosition;
+
+                Assert.IsNotNull(positionData);
+                Assert.IsNotNull(curveData);
+                Assert.AreEqual(new Vector2(192, 168), positionData.Position);
+                Assert.AreEqual(956, hitObjects[0].StartTime);
+                Assert.IsTrue(hitObjects[0].Samples.Any(s => s.Name == SampleInfo.HIT_NORMAL));
+
+                positionData = hitObjects[1] as IHasPosition;
+
+                Assert.IsNotNull(positionData);
+                Assert.AreEqual(new Vector2(304, 56), positionData.Position);
+                Assert.AreEqual(1285, hitObjects[1].StartTime);
+                Assert.IsTrue(hitObjects[1].Samples.Any(s => s.Name == SampleInfo.HIT_CLAP));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,90 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+using OpenTK;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps.Formats;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Tests.Beatmaps.Formats
+{
+    [TestFixture]
+    public class LegacyStoryboardDecoderTest
+    {
+        [Test]
+        public void TestDecodeStoryboardEvents()
+        {
+            var decoder = new LegacyBeatmapDecoder();
+            using (var resStream = Resource.OpenResource("Himeringo - Yotsuya-san ni Yoroshiku (RLC) [Winber1's Extreme].osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var storyboard = decoder.GetStoryboardDecoder().DecodeStoryboard(stream);
+
+                Assert.IsTrue(storyboard.HasDrawable);
+                Assert.AreEqual(4, storyboard.Layers.Count());
+
+                StoryboardLayer background = storyboard.Layers.FirstOrDefault(l => l.Depth == 3);
+                Assert.IsNotNull(background);
+                Assert.AreEqual(16, background.Elements.Count());
+                Assert.IsTrue(background.EnabledWhenFailing);
+                Assert.IsTrue(background.EnabledWhenPassing);
+                Assert.AreEqual("Background", background.Name);
+
+                StoryboardLayer fail = storyboard.Layers.FirstOrDefault(l => l.Depth == 2);
+                Assert.IsNotNull(fail);
+                Assert.AreEqual(0, fail.Elements.Count());
+                Assert.IsTrue(fail.EnabledWhenFailing);
+                Assert.IsFalse(fail.EnabledWhenPassing);
+                Assert.AreEqual("Fail", fail.Name);
+
+                StoryboardLayer pass = storyboard.Layers.FirstOrDefault(l => l.Depth == 1);
+                Assert.IsNotNull(pass);
+                Assert.AreEqual(0, pass.Elements.Count());
+                Assert.IsFalse(pass.EnabledWhenFailing);
+                Assert.IsTrue(pass.EnabledWhenPassing);
+                Assert.AreEqual("Pass", pass.Name);
+
+                StoryboardLayer foreground = storyboard.Layers.FirstOrDefault(l => l.Depth == 0);
+                Assert.IsNotNull(foreground);
+                Assert.AreEqual(151, foreground.Elements.Count());
+                Assert.IsTrue(foreground.EnabledWhenFailing);
+                Assert.IsTrue(foreground.EnabledWhenPassing);
+                Assert.AreEqual("Foreground", foreground.Name);
+
+                int spriteCount = background.Elements.Count(x => x.GetType() == typeof(StoryboardSprite));
+                int animationCount = background.Elements.Count(x => x.GetType() == typeof(StoryboardAnimation));
+                int sampleCount = background.Elements.Count(x => x.GetType() == typeof(StoryboardSample));
+
+                Assert.AreEqual(15, spriteCount);
+                Assert.AreEqual(1, animationCount);
+                Assert.AreEqual(0, sampleCount);
+                Assert.AreEqual(background.Elements.Count(), spriteCount + animationCount + sampleCount);
+
+                var sprite = background.Elements.ElementAt(0) as StoryboardSprite;
+                Assert.NotNull(sprite);
+                Assert.IsTrue(sprite.HasCommands);
+                Assert.AreEqual(new Vector2(320, 240), sprite.InitialPosition);
+                Assert.IsTrue(sprite.IsDrawable);
+                Assert.AreEqual(Anchor.Centre, sprite.Origin);
+                Assert.AreEqual("SB/lyric/ja-21.png", sprite.Path);
+
+                var animation = background.Elements.ElementAt(12) as StoryboardAnimation;
+                Assert.NotNull(animation);
+                Assert.AreEqual(141175, animation.EndTime);
+                Assert.AreEqual(10, animation.FrameCount);
+                Assert.AreEqual(30, animation.FrameDelay);
+                Assert.IsTrue(animation.HasCommands);
+                Assert.AreEqual(new Vector2(320, 240), animation.InitialPosition);
+                Assert.IsTrue(animation.IsDrawable);
+                Assert.AreEqual(AnimationLoopType.LoopForever, animation.LoopType);
+                Assert.AreEqual(Anchor.Centre, animation.Origin);
+                Assert.AreEqual("SB/red jitter/red_0000.jpg", animation.Path);
+                Assert.AreEqual(78993, animation.StartTime);
+            }
+        }
+    }
+}

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

@@ -1,146 +0,0 @@
-// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System.IO;
-using NUnit.Framework;
-using OpenTK;
-using OpenTK.Graphics;
-using osu.Game.Beatmaps.Formats;
-using osu.Game.Tests.Resources;
-using System.Linq;
-using osu.Game.Audio;
-using osu.Game.Rulesets.Objects.Types;
-
-namespace osu.Game.Tests.Beatmaps.Formats
-{
-    [TestFixture]
-    public class OsuLegacyDecoderTest
-    {
-        [Test]
-        public void TestDecodeMetadata()
-        {
-            var decoder = new OsuLegacyDecoder();
-            using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            {
-                var beatmap = decoder.Decode(new StreamReader(stream));
-                var meta = beatmap.BeatmapInfo.Metadata;
-                Assert.AreEqual(241526, meta.OnlineBeatmapSetID);
-                Assert.AreEqual("Soleily", meta.Artist);
-                Assert.AreEqual("Soleily", meta.ArtistUnicode);
-                Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", meta.AudioFile);
-                Assert.AreEqual("Gamu", meta.AuthorString);
-                Assert.AreEqual("machinetop_background.jpg", meta.BackgroundFile);
-                Assert.AreEqual(164471, meta.PreviewTime);
-                Assert.AreEqual(string.Empty, meta.Source);
-                Assert.AreEqual("MBC7 Unisphere 地球ヤバイEP Chikyu Yabai", meta.Tags);
-                Assert.AreEqual("Renatus", meta.Title);
-                Assert.AreEqual("Renatus", meta.TitleUnicode);
-            }
-        }
-
-        [Test]
-        public void TestDecodeGeneral()
-        {
-            var decoder = new OsuLegacyDecoder();
-            using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            {
-                var beatmapInfo = decoder.Decode(new StreamReader(stream)).BeatmapInfo;
-                Assert.AreEqual(0, beatmapInfo.AudioLeadIn);
-                Assert.AreEqual(false, beatmapInfo.Countdown);
-                Assert.AreEqual(0.7f, beatmapInfo.StackLeniency);
-                Assert.AreEqual(false, beatmapInfo.SpecialStyle);
-                Assert.IsTrue(beatmapInfo.RulesetID == 0);
-                Assert.AreEqual(false, beatmapInfo.LetterboxInBreaks);
-                Assert.AreEqual(false, beatmapInfo.WidescreenStoryboard);
-            }
-        }
-
-        [Test]
-        public void TestDecodeEditor()
-        {
-            var decoder = new OsuLegacyDecoder();
-            using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            {
-                var beatmap = decoder.Decode(new StreamReader(stream)).BeatmapInfo;
-                int[] expectedBookmarks =
-                {
-                    11505, 22054, 32604, 43153, 53703, 64252, 74802, 85351,
-                    95901, 106450, 116999, 119637, 130186, 140735, 151285,
-                    161834, 164471, 175020, 185570, 196119, 206669, 209306
-                };
-                Assert.AreEqual(expectedBookmarks.Length, beatmap.Bookmarks.Length);
-                for (int i = 0; i < expectedBookmarks.Length; i++)
-                    Assert.AreEqual(expectedBookmarks[i], beatmap.Bookmarks[i]);
-                Assert.AreEqual(1.8, beatmap.DistanceSpacing);
-                Assert.AreEqual(4, beatmap.BeatDivisor);
-                Assert.AreEqual(4, beatmap.GridSize);
-                Assert.AreEqual(2, beatmap.TimelineZoom);
-            }
-        }
-
-        [Test]
-        public void TestDecodeDifficulty()
-        {
-            var decoder = new OsuLegacyDecoder();
-            using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            {
-                var beatmap = decoder.Decode(new StreamReader(stream));
-                var difficulty = beatmap.BeatmapInfo.BaseDifficulty;
-                Assert.AreEqual(6.5f, difficulty.DrainRate);
-                Assert.AreEqual(4, difficulty.CircleSize);
-                Assert.AreEqual(8, difficulty.OverallDifficulty);
-                Assert.AreEqual(9, difficulty.ApproachRate);
-                Assert.AreEqual(1.8f, difficulty.SliderMultiplier);
-                Assert.AreEqual(2, difficulty.SliderTickRate);
-            }
-        }
-
-        [Test]
-        public void TestDecodeColors()
-        {
-            var decoder = new OsuLegacyDecoder();
-            using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            {
-                var beatmap = decoder.Decode(new StreamReader(stream));
-                Color4[] expected =
-                {
-                    new Color4(142, 199, 255, 255),
-                    new Color4(255, 128, 128, 255),
-                    new Color4(128, 255, 255, 255),
-                    new Color4(128, 255, 128, 255),
-                    new Color4(255, 187, 255, 255),
-                    new Color4(255, 177, 140, 255),
-                };
-                Assert.AreEqual(expected.Length, beatmap.ComboColors.Count);
-                for (int i = 0; i < expected.Length; i++)
-                    Assert.AreEqual(expected[i], beatmap.ComboColors[i]);
-            }
-        }
-
-        [Test]
-        public void TestDecodeHitObjects()
-        {
-            var decoder = new OsuLegacyDecoder();
-            using (var stream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
-            {
-                var beatmap = decoder.Decode(new StreamReader(stream));
-
-                var curveData = beatmap.HitObjects[0] as IHasCurve;
-                var positionData = beatmap.HitObjects[0] as IHasPosition;
-
-                Assert.IsNotNull(positionData);
-                Assert.IsNotNull(curveData);
-                Assert.AreEqual(new Vector2(192, 168), positionData.Position);
-                Assert.AreEqual(956, beatmap.HitObjects[0].StartTime);
-                Assert.IsTrue(beatmap.HitObjects[0].Samples.Any(s => s.Name == SampleInfo.HIT_NORMAL));
-
-                positionData = beatmap.HitObjects[1] as IHasPosition;
-
-                Assert.IsNotNull(positionData);
-                Assert.AreEqual(new Vector2(304, 56), positionData.Position);
-                Assert.AreEqual(1285, beatmap.HitObjects[1].StartTime);
-                Assert.IsTrue(beatmap.HitObjects[1].Samples.Any(s => s.Name == SampleInfo.HIT_CLAP));
-            }
-        }
-    }
-}

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

@@ -50,7 +50,7 @@ namespace osu.Game.Tests.Beatmaps.IO
 
                 BeatmapMetadata meta;
                 using (var stream = new StreamReader(reader.GetStream("Soleily - Renatus (Deif) [Platter].osu")))
-                    meta = BeatmapDecoder.GetDecoder(stream).Decode(stream).Metadata;
+                    meta = Decoder.GetDecoder(stream).DecodeBeatmap(stream).Metadata;
 
                 Assert.AreEqual(241526, meta.OnlineBeatmapSetID);
                 Assert.AreEqual("Soleily", meta.Artist);

osu.Game.Tests/Visual/TestCaseStoryboard.cs

@@ -79,7 +79,7 @@ namespace osu.Game.Tests.Visual
             var decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = true };
             storyboardContainer.Clock = decoupledClock;
 
-            storyboard = working.Beatmap.Storyboard.CreateDrawable(beatmapBacking);
+            storyboard = working.Storyboard.CreateDrawable(beatmapBacking);
             storyboard.Passing = false;
 
             storyboardContainer.Add(storyboard);

osu.Game.Tests/osu.Game.Tests.csproj

@@ -83,10 +83,11 @@
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Beatmaps\Formats\LegacyStoryboardDecoderTest.cs" />
     <Compile Include="Beatmaps\IO\OszArchiveReaderTest.cs" />
     <Compile Include="Beatmaps\IO\ImportBeatmapTest.cs" />
     <Compile Include="Resources\Resource.cs" />
-    <Compile Include="Beatmaps\Formats\OsuLegacyDecoderTest.cs" />
+    <Compile Include="Beatmaps\Formats\LegacyBeatmapDecoderTest.cs" />
     <Compile Include="Visual\TestCaseBeatmapDetailArea.cs" />
     <Compile Include="Visual\TestCaseBeatmapDetails.cs" />
     <Compile Include="Visual\TestCaseBeatmapOptionsOverlay.cs" />
@@ -146,6 +147,7 @@
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Resources\Soleily - Renatus %28Gamu%29 [Insane].osu" />
+    <EmbeddedResource Include="Resources\Himeringo - Yotsuya-san ni Yoroshiku %28RLC%29 [Winber1%27s Extreme].osu" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
 </Project>

osu.Game/Beatmaps/Beatmap.cs

@@ -8,7 +8,6 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.IO.Serialization;
-using osu.Game.Storyboards;
 
 namespace osu.Game.Beatmaps
 {
@@ -41,11 +40,6 @@ namespace osu.Game.Beatmaps
         /// </summary>
         public double TotalBreakTime => Breaks.Sum(b => b.Duration);
 
-        /// <summary>
-        /// The Beatmap's Storyboard.
-        /// </summary>
-        public Storyboard Storyboard = new Storyboard();
-
         /// <summary>
         /// Constructs a new beatmap.
         /// </summary>
@@ -57,7 +51,6 @@ namespace osu.Game.Beatmaps
             Breaks = original?.Breaks ?? Breaks;
             ComboColors = original?.ComboColors ?? ComboColors;
             HitObjects = original?.HitObjects ?? HitObjects;
-            Storyboard = original?.Storyboard ?? Storyboard;
 
             if (original == null && Metadata == null)
             {

osu.Game/Beatmaps/BeatmapManager.cs

@@ -25,6 +25,7 @@ using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Rulesets;
+using osu.Game.Storyboards;
 
 namespace osu.Game.Beatmaps
 {
@@ -494,10 +495,15 @@ namespace osu.Game.Beatmaps
             BeatmapMetadata metadata;
 
             using (var stream = new StreamReader(reader.GetStream(mapName)))
-                metadata = BeatmapDecoder.GetDecoder(stream).Decode(stream).Metadata;
+                metadata = Decoder.GetDecoder(stream).DecodeBeatmap(stream).Metadata;
+
 
             // check if a set already exists with the same online id.
-            beatmapSet = beatmaps.BeatmapSets.FirstOrDefault(b => b.OnlineBeatmapSetID == metadata.OnlineBeatmapSetID) ?? new BeatmapSetInfo
+            if (metadata.OnlineBeatmapSetID != null)
+                beatmapSet = beatmaps.BeatmapSets.FirstOrDefault(b => b.OnlineBeatmapSetID == metadata.OnlineBeatmapSetID);
+
+            if (beatmapSet == null)
+                beatmapSet = new BeatmapSetInfo
                 {
                     OnlineBeatmapSetID = metadata.OnlineBeatmapSetID,
                     Beatmaps = new List<BeatmapInfo>(),
@@ -506,6 +512,7 @@ namespace osu.Game.Beatmaps
                     Metadata = metadata
                 };
 
+
             var mapNames = reader.Filenames.Where(f => f.EndsWith(".osu"));
 
             foreach (var name in mapNames)
@@ -517,14 +524,14 @@ namespace osu.Game.Beatmaps
                     raw.CopyTo(ms);
                     ms.Position = 0;
 
-                    var decoder = BeatmapDecoder.GetDecoder(sr);
+                    var decoder = Decoder.GetDecoder(sr);
-                    Beatmap beatmap = decoder.Decode(sr);
+                    Beatmap beatmap = decoder.DecodeBeatmap(sr);
 
                     beatmap.BeatmapInfo.Path = name;
                     beatmap.BeatmapInfo.Hash = ms.ComputeSHA2Hash();
                     beatmap.BeatmapInfo.MD5Hash = ms.ComputeMD5Hash();
 
-                    var existing = beatmaps.Beatmaps.FirstOrDefault(b => b.Hash == beatmap.BeatmapInfo.Hash || b.OnlineBeatmapID == beatmap.BeatmapInfo.OnlineBeatmapID);
+                    var existing = beatmaps.Beatmaps.FirstOrDefault(b => b.Hash == beatmap.BeatmapInfo.Hash || beatmap.BeatmapInfo.OnlineBeatmapID != null && b.OnlineBeatmapID == beatmap.BeatmapInfo.OnlineBeatmapID);
 
                     if (existing == null)
                     {
@@ -568,23 +575,11 @@ namespace osu.Game.Beatmaps
             {
                 try
                 {
-                    Beatmap beatmap;
-
-                    BeatmapDecoder decoder;
                     using (var stream = new StreamReader(store.GetStream(getPathForFile(BeatmapInfo.Path))))
                     {
-                        decoder = BeatmapDecoder.GetDecoder(stream);
+                        Decoder decoder = Decoder.GetDecoder(stream);
-                        beatmap = decoder.Decode(stream);
+                        return decoder.DecodeBeatmap(stream);
                     }
-
-                    if (beatmap == null || BeatmapSetInfo.StoryboardFile == null)
-                        return beatmap;
-
-                    using (var stream = new StreamReader(store.GetStream(getPathForFile(BeatmapSetInfo.StoryboardFile))))
-                        decoder.Decode(stream, beatmap);
-
-
-                    return beatmap;
                 }
                 catch
                 {
@@ -623,6 +618,28 @@ namespace osu.Game.Beatmaps
             }
 
             protected override Waveform GetWaveform() => new Waveform(store.GetStream(getPathForFile(Metadata.AudioFile)));
+
+            protected override Storyboard GetStoryboard()
+            {
+                if (BeatmapInfo?.Path == null && BeatmapSetInfo?.StoryboardFile == null)
+                    return new Storyboard();
+
+                try
+                {
+                    Decoder decoder;
+                    using (var stream = new StreamReader(store.GetStream(getPathForFile(BeatmapInfo?.Path))))
+                        decoder = Decoder.GetDecoder(stream);
+
+                    // try for .osb first and fall back to .osu
+                    string storyboardFile = BeatmapSetInfo.StoryboardFile ?? BeatmapInfo.Path;
+                    using (var stream = new StreamReader(store.GetStream(getPathForFile(storyboardFile))))
+                        return decoder.GetStoryboardDecoder().DecodeStoryboard(stream);
+                }
+                catch
+                {
+                    return new Storyboard();
+                }
+            }
         }
 
         /// <summary>

osu.Game/Beatmaps/Formats/BeatmapDecoder.cs

@@ -1,65 +0,0 @@
-// Copyright (c) 2007-2017 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.IO;
-
-namespace osu.Game.Beatmaps.Formats
-{
-    public abstract class BeatmapDecoder
-    {
-        private static readonly Dictionary<string, Type> decoders = new Dictionary<string, Type>();
-
-        static BeatmapDecoder()
-        {
-            OsuLegacyDecoder.Register();
-        }
-
-        public static BeatmapDecoder GetDecoder(StreamReader stream)
-        {
-            if (stream == null)
-                throw new ArgumentNullException(nameof(stream));
-
-            string line;
-            do { line = stream.ReadLine()?.Trim(); }
-            while (line != null && line.Length == 0);
-
-            if (line == null || !decoders.ContainsKey(line))
-                throw new IOException(@"Unknown file format");
-            return (BeatmapDecoder)Activator.CreateInstance(decoders[line], line);
-        }
-
-        protected static void AddDecoder<T>(string magic) where T : BeatmapDecoder
-        {
-            decoders[magic] = typeof(T);
-        }
-
-        public virtual Beatmap Decode(StreamReader stream)
-        {
-            return ParseFile(stream);
-        }
-
-        public virtual void Decode(StreamReader stream, Beatmap beatmap)
-        {
-            ParseFile(stream, beatmap);
-        }
-
-        protected virtual Beatmap ParseFile(StreamReader stream)
-        {
-            var beatmap = new Beatmap
-            {
-                BeatmapInfo = new BeatmapInfo
-                {
-                    Metadata = new BeatmapMetadata(),
-                    BaseDifficulty = new BeatmapDifficulty(),
-                },
-            };
-
-            ParseFile(stream, beatmap);
-            return beatmap;
-        }
-
-        protected abstract void ParseFile(StreamReader stream, Beatmap beatmap);
-    }
-}

osu.Game/Beatmaps/Formats/Decoder.cs

@@ -0,0 +1,80 @@
+// Copyright (c) 2007-2017 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.IO;
+using osu.Game.Storyboards;
+
+namespace osu.Game.Beatmaps.Formats
+{
+    public abstract class Decoder
+    {
+        private static readonly Dictionary<string, Type> decoders = new Dictionary<string, Type>();
+
+        static Decoder()
+        {
+            LegacyDecoder.Register();
+        }
+
+        /// <summary>
+        /// Retrieves a <see cref="Decoder"/> to parse a <see cref="Beatmap"/>.
+        /// </summary>
+        /// <param name="stream">A stream pointing to the <see cref="Beatmap"/>.</param>
+        public static Decoder GetDecoder(StreamReader stream)
+        {
+            if (stream == null)
+                throw new ArgumentNullException(nameof(stream));
+
+            string line;
+            do
+            { line = stream.ReadLine()?.Trim(); }
+            while (line != null && line.Length == 0);
+
+            if (line == null || !decoders.ContainsKey(line))
+                throw new IOException(@"Unknown file format");
+            return (Decoder)Activator.CreateInstance(decoders[line], line);
+        }
+
+        /// <summary>
+        /// Adds the <see cref="Decoder"/> to the list of <see cref="Beatmap"/> and <see cref="Storyboard"/> decoder.
+        /// </summary>
+        /// <typeparam name="T">Type to decode a <see cref="Beatmap"/> with.</typeparam>
+        /// <param name="version">A string representation of the version.</param>
+        protected static void AddDecoder<T>(string version) where T : Decoder
+        {
+            decoders[version] = typeof(T);
+        }
+
+        /// <summary>
+        /// Retrieves a <see cref="Decoder"/> to parse a <see cref="Storyboard"/>
+        /// </summary>
+        public abstract Decoder GetStoryboardDecoder();
+
+        public virtual Beatmap DecodeBeatmap(StreamReader stream)
+        {
+            var beatmap = new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Metadata = new BeatmapMetadata(),
+                    BaseDifficulty = new BeatmapDifficulty(),
+                },
+            };
+
+            ParseBeatmap(stream, beatmap);
+            return beatmap;
+        }
+
+        protected abstract void ParseBeatmap(StreamReader stream, Beatmap beatmap);
+
+        public virtual Storyboard DecodeStoryboard(StreamReader stream)
+        {
+            var storyboard = new Storyboard();
+            ParseStoryboard(stream, storyboard);
+            return storyboard;
+        }
+
+        protected abstract void ParseStoryboard(StreamReader stream, Storyboard storyboard);
+    }
+}

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -0,0 +1,421 @@
+// Copyright (c) 2007-2017 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 System.IO;
+using OpenTK.Graphics;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Objects.Legacy;
+using osu.Game.Beatmaps.ControlPoints;
+using System.Collections.Generic;
+
+namespace osu.Game.Beatmaps.Formats
+{
+    public class LegacyBeatmapDecoder : LegacyDecoder
+    {
+        private Beatmap beatmap;
+
+        private bool hasCustomColours;
+        private ConvertHitObjectParser parser;
+
+        private LegacySampleBank defaultSampleBank;
+        private int defaultSampleVolume = 100;
+
+        public LegacyBeatmapDecoder()
+        {
+        }
+
+        public LegacyBeatmapDecoder(string header)
+        {
+            BeatmapVersion = int.Parse(header.Substring(17));
+        }
+
+        protected override void ParseBeatmap(StreamReader stream, Beatmap beatmap)
+        {
+            if (stream == null)
+                throw new ArgumentNullException(nameof(stream));
+            if (beatmap == null)
+                throw new ArgumentNullException(nameof(beatmap));
+
+            this.beatmap = beatmap;
+            this.beatmap.BeatmapInfo.BeatmapVersion = BeatmapVersion;
+
+            ParseContent(stream);
+
+            foreach (var hitObject in this.beatmap.HitObjects)
+                hitObject.ApplyDefaults(this.beatmap.ControlPointInfo, this.beatmap.BeatmapInfo.BaseDifficulty);
+        }
+
+        protected override bool ShouldSkipLine(string line)
+        {
+            if (base.ShouldSkipLine(line) || line.StartsWith(" ") || line.StartsWith("_"))
+                return true;
+            return false;
+        }
+
+        protected override void ProcessSection(Section section, string line)
+        {
+            switch (section)
+            {
+                case Section.General:
+                    handleGeneral(line);
+                    break;
+                case Section.Editor:
+                    handleEditor(line);
+                    break;
+                case Section.Metadata:
+                    handleMetadata(line);
+                    break;
+                case Section.Difficulty:
+                    handleDifficulty(line);
+                    break;
+                case Section.Events:
+                    handleEvents(line);
+                    break;
+                case Section.TimingPoints:
+                    handleTimingPoints(line);
+                    break;
+                case Section.Colours:
+                    handleColours(line);
+                    break;
+                case Section.HitObjects:
+                    handleHitObjects(line);
+                    break;
+                case Section.Variables:
+                    handleVariables(line);
+                    break;
+            }
+        }
+
+        private void handleGeneral(string line)
+        {
+            var pair = splitKeyVal(line, ':');
+
+            var metadata = beatmap.BeatmapInfo.Metadata;
+            switch (pair.Key)
+            {
+                case @"AudioFilename":
+                    metadata.AudioFile = pair.Value;
+                    break;
+                case @"AudioLeadIn":
+                    beatmap.BeatmapInfo.AudioLeadIn = int.Parse(pair.Value);
+                    break;
+                case @"PreviewTime":
+                    metadata.PreviewTime = int.Parse(pair.Value);
+                    break;
+                case @"Countdown":
+                    beatmap.BeatmapInfo.Countdown = int.Parse(pair.Value) == 1;
+                    break;
+                case @"SampleSet":
+                    defaultSampleBank = (LegacySampleBank)Enum.Parse(typeof(LegacySampleBank), pair.Value);
+                    break;
+                case @"SampleVolume":
+                    defaultSampleVolume = int.Parse(pair.Value);
+                    break;
+                case @"StackLeniency":
+                    beatmap.BeatmapInfo.StackLeniency = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    break;
+                case @"Mode":
+                    beatmap.BeatmapInfo.RulesetID = int.Parse(pair.Value);
+
+                    switch (beatmap.BeatmapInfo.RulesetID)
+                    {
+                        case 0:
+                            parser = new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser();
+                            break;
+                        case 1:
+                            parser = new Rulesets.Objects.Legacy.Taiko.ConvertHitObjectParser();
+                            break;
+                        case 2:
+                            parser = new Rulesets.Objects.Legacy.Catch.ConvertHitObjectParser();
+                            break;
+                        case 3:
+                            parser = new Rulesets.Objects.Legacy.Mania.ConvertHitObjectParser();
+                            break;
+                    }
+                    break;
+                case @"LetterboxInBreaks":
+                    beatmap.BeatmapInfo.LetterboxInBreaks = int.Parse(pair.Value) == 1;
+                    break;
+                case @"SpecialStyle":
+                    beatmap.BeatmapInfo.SpecialStyle = int.Parse(pair.Value) == 1;
+                    break;
+                case @"WidescreenStoryboard":
+                    beatmap.BeatmapInfo.WidescreenStoryboard = int.Parse(pair.Value) == 1;
+                    break;
+            }
+        }
+
+        private void handleEditor(string line)
+        {
+            var pair = splitKeyVal(line, ':');
+
+            switch (pair.Key)
+            {
+                case @"Bookmarks":
+                    beatmap.BeatmapInfo.StoredBookmarks = pair.Value;
+                    break;
+                case @"DistanceSpacing":
+                    beatmap.BeatmapInfo.DistanceSpacing = double.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    break;
+                case @"BeatDivisor":
+                    beatmap.BeatmapInfo.BeatDivisor = int.Parse(pair.Value);
+                    break;
+                case @"GridSize":
+                    beatmap.BeatmapInfo.GridSize = int.Parse(pair.Value);
+                    break;
+                case @"TimelineZoom":
+                    beatmap.BeatmapInfo.TimelineZoom = double.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    break;
+            }
+        }
+
+        private void handleMetadata(string line)
+        {
+            var pair = splitKeyVal(line, ':');
+
+            var metadata = beatmap.BeatmapInfo.Metadata;
+            switch (pair.Key)
+            {
+                case @"Title":
+                    metadata.Title = pair.Value;
+                    break;
+                case @"TitleUnicode":
+                    metadata.TitleUnicode = pair.Value;
+                    break;
+                case @"Artist":
+                    metadata.Artist = pair.Value;
+                    break;
+                case @"ArtistUnicode":
+                    metadata.ArtistUnicode = pair.Value;
+                    break;
+                case @"Creator":
+                    metadata.AuthorString = pair.Value;
+                    break;
+                case @"Version":
+                    beatmap.BeatmapInfo.Version = pair.Value;
+                    break;
+                case @"Source":
+                    beatmap.BeatmapInfo.Metadata.Source = pair.Value;
+                    break;
+                case @"Tags":
+                    beatmap.BeatmapInfo.Metadata.Tags = pair.Value;
+                    break;
+                case @"BeatmapID":
+                    beatmap.BeatmapInfo.OnlineBeatmapID = int.Parse(pair.Value);
+                    break;
+                case @"BeatmapSetID":
+                    beatmap.BeatmapInfo.OnlineBeatmapSetID = int.Parse(pair.Value);
+                    metadata.OnlineBeatmapSetID = int.Parse(pair.Value);
+                    break;
+            }
+        }
+
+        private void handleDifficulty(string line)
+        {
+            var pair = splitKeyVal(line, ':');
+
+            var difficulty = beatmap.BeatmapInfo.BaseDifficulty;
+            switch (pair.Key)
+            {
+                case @"HPDrainRate":
+                    difficulty.DrainRate = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    break;
+                case @"CircleSize":
+                    difficulty.CircleSize = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    break;
+                case @"OverallDifficulty":
+                    difficulty.OverallDifficulty = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    break;
+                case @"ApproachRate":
+                    difficulty.ApproachRate = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    break;
+                case @"SliderMultiplier":
+                    difficulty.SliderMultiplier = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    break;
+                case @"SliderTickRate":
+                    difficulty.SliderTickRate = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
+                    break;
+            }
+        }
+
+        private void handleEvents(string line)
+        {
+            DecodeVariables(ref line);
+
+            string[] split = line.Split(',');
+
+            EventType type;
+            if (!Enum.TryParse(split[0], out type))
+                throw new InvalidDataException($@"Unknown event type {split[0]}");
+
+            switch (type)
+            {
+                case EventType.Background:
+                    string filename = split[2].Trim('"');
+                    beatmap.BeatmapInfo.Metadata.BackgroundFile = filename;
+                    break;
+                case EventType.Break:
+                    var breakEvent = new BreakPeriod
+                    {
+                        StartTime = double.Parse(split[1], NumberFormatInfo.InvariantInfo),
+                        EndTime = double.Parse(split[2], NumberFormatInfo.InvariantInfo)
+                    };
+
+                    if (!breakEvent.HasEffect)
+                        return;
+
+                    beatmap.Breaks.Add(breakEvent);
+                    break;
+            }
+        }
+
+        private void handleTimingPoints(string line)
+        {
+            string[] split = line.Split(',');
+
+            double time = double.Parse(split[0].Trim(), NumberFormatInfo.InvariantInfo);
+            double beatLength = double.Parse(split[1].Trim(), NumberFormatInfo.InvariantInfo);
+            double speedMultiplier = beatLength < 0 ? 100.0 / -beatLength : 1;
+
+            TimeSignatures timeSignature = TimeSignatures.SimpleQuadruple;
+            if (split.Length >= 3)
+                timeSignature = split[2][0] == '0' ? TimeSignatures.SimpleQuadruple : (TimeSignatures)int.Parse(split[2]);
+
+            LegacySampleBank sampleSet = defaultSampleBank;
+            if (split.Length >= 4)
+                sampleSet = (LegacySampleBank)int.Parse(split[3]);
+
+            //SampleBank sampleBank = SampleBank.Default;
+            //if (split.Length >= 5)
+            //    sampleBank = (SampleBank)int.Parse(split[4]);
+
+            int sampleVolume = defaultSampleVolume;
+            if (split.Length >= 6)
+                sampleVolume = int.Parse(split[5]);
+
+            bool timingChange = true;
+            if (split.Length >= 7)
+                timingChange = split[6][0] == '1';
+
+            bool kiaiMode = false;
+            bool omitFirstBarSignature = false;
+            if (split.Length >= 8)
+            {
+                int effectFlags = int.Parse(split[7]);
+                kiaiMode = (effectFlags & 1) > 0;
+                omitFirstBarSignature = (effectFlags & 8) > 0;
+            }
+
+            string stringSampleSet = sampleSet.ToString().ToLower();
+            if (stringSampleSet == @"none")
+                stringSampleSet = @"normal";
+
+            DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(time);
+            SoundControlPoint soundPoint = beatmap.ControlPointInfo.SoundPointAt(time);
+            EffectControlPoint effectPoint = beatmap.ControlPointInfo.EffectPointAt(time);
+
+            if (timingChange)
+            {
+                beatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint
+                {
+                    Time = time,
+                    BeatLength = beatLength,
+                    TimeSignature = timeSignature
+                });
+            }
+
+            if (speedMultiplier != difficultyPoint.SpeedMultiplier)
+            {
+                beatmap.ControlPointInfo.DifficultyPoints.RemoveAll(x => x.Time == time);
+                beatmap.ControlPointInfo.DifficultyPoints.Add(new DifficultyControlPoint
+                {
+                    Time = time,
+                    SpeedMultiplier = speedMultiplier
+                });
+            }
+
+            if (stringSampleSet != soundPoint.SampleBank || sampleVolume != soundPoint.SampleVolume)
+            {
+                beatmap.ControlPointInfo.SoundPoints.Add(new SoundControlPoint
+                {
+                    Time = time,
+                    SampleBank = stringSampleSet,
+                    SampleVolume = sampleVolume
+                });
+            }
+
+            if (kiaiMode != effectPoint.KiaiMode || omitFirstBarSignature != effectPoint.OmitFirstBarLine)
+            {
+                beatmap.ControlPointInfo.EffectPoints.Add(new EffectControlPoint
+                {
+                    Time = time,
+                    KiaiMode = kiaiMode,
+                    OmitFirstBarLine = omitFirstBarSignature
+                });
+            }
+        }
+
+        private void handleColours(string line)
+        {
+            var pair = splitKeyVal(line, ':');
+
+            string[] split = pair.Value.Split(',');
+
+            if (split.Length != 3)
+                throw new InvalidOperationException($@"Color specified in incorrect format (should be R,G,B): {pair.Value}");
+
+            byte r, g, b;
+            if (!byte.TryParse(split[0], out r) || !byte.TryParse(split[1], out g) || !byte.TryParse(split[2], out b))
+                throw new InvalidOperationException(@"Color must be specified with 8-bit integer components");
+
+            if (!hasCustomColours)
+            {
+                beatmap.ComboColors.Clear();
+                hasCustomColours = true;
+            }
+
+            // Note: the combo index specified in the beatmap is discarded
+            if (pair.Key.StartsWith(@"Combo"))
+            {
+                beatmap.ComboColors.Add(new Color4
+                {
+                    R = r / 255f,
+                    G = g / 255f,
+                    B = b / 255f,
+                    A = 1f,
+                });
+            }
+        }
+
+        private void handleHitObjects(string line)
+        {
+            // If the ruleset wasn't specified, assume the osu!standard ruleset.
+            if (parser == null)
+                parser = new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser();
+
+            var obj = parser.Parse(line);
+
+            if (obj != null)
+                beatmap.HitObjects.Add(obj);
+        }
+
+        private void handleVariables(string line)
+        {
+            var pair = splitKeyVal(line, '=');
+            Variables[pair.Key] = pair.Value;
+        }
+
+        private KeyValuePair<string, string> splitKeyVal(string line, char separator)
+        {
+            var split = line.Trim().Split(new[] { separator }, 2);
+
+            return new KeyValuePair<string, string>
+            (
+                split[0].Trim(),
+                split.Length > 1 ? split[1].Trim() : string.Empty
+            );
+        }
+    }
+}

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -0,0 +1,163 @@
+// Copyright (c) 2007-2017 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.IO;
+using osu.Game.Beatmaps.Legacy;
+using osu.Game.Storyboards;
+
+namespace osu.Game.Beatmaps.Formats
+{
+    public abstract class LegacyDecoder : Decoder
+    {
+        public static void Register()
+        {
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v14");
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v13");
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v12");
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v11");
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v10");
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v9");
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v8");
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v7");
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v6");
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v5");
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v4");
+            AddDecoder<LegacyBeatmapDecoder>(@"osu file format v3");
+            // TODO: differences between versions
+        }
+
+        protected int BeatmapVersion;
+        protected readonly Dictionary<string, string> Variables = new Dictionary<string, string>();
+
+        public override Decoder GetStoryboardDecoder() => new LegacyStoryboardDecoder(BeatmapVersion);
+
+        public override Beatmap DecodeBeatmap(StreamReader stream) => new LegacyBeatmap(base.DecodeBeatmap(stream));
+
+        protected override void ParseBeatmap(StreamReader stream, Beatmap beatmap)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected override void ParseStoryboard(StreamReader stream, Storyboard storyboard)
+        {
+            throw new NotImplementedException();
+        }
+
+        protected void ParseContent(StreamReader stream)
+        {
+            Section section = Section.None;
+
+            string line;
+            while ((line = stream.ReadLine()) != null)
+            {
+                if (ShouldSkipLine(line))
+                    continue;
+
+                // It's already set in ParseBeatmap... why do it again?
+                //if (line.StartsWith(@"osu file format v"))
+                //{
+                //    Beatmap.BeatmapInfo.BeatmapVersion = int.Parse(line.Substring(17));
+                //    continue;
+                //}
+
+                if (line.StartsWith(@"[") && line.EndsWith(@"]"))
+                {
+                    if (!Enum.TryParse(line.Substring(1, line.Length - 2), out section))
+                        throw new InvalidDataException($@"Unknown osu section {line}");
+                    continue;
+                }
+
+                ProcessSection(section, line);
+            }
+        }
+
+        protected virtual bool ShouldSkipLine(string line)
+        {
+            if (string.IsNullOrWhiteSpace(line) || line.StartsWith("//"))
+                return true;
+            return false;
+        }
+
+        protected abstract void ProcessSection(Section section, string line);
+
+        /// <summary>
+        /// Decodes any beatmap variables present in a line into their real values.
+        /// </summary>
+        /// <param name="line">The line which may contains variables.</param>
+        protected void DecodeVariables(ref string line)
+        {
+            while (line.IndexOf('$') >= 0)
+            {
+                string origLine = line;
+                string[] split = line.Split(',');
+                for (int i = 0; i < split.Length; i++)
+                {
+                    var item = split[i];
+                    if (item.StartsWith("$") && Variables.ContainsKey(item))
+                        split[i] = Variables[item];
+                }
+
+                line = string.Join(",", split);
+                if (line == origLine)
+                    break;
+            }
+        }
+
+        protected enum Section
+        {
+            None,
+            General,
+            Editor,
+            Metadata,
+            Difficulty,
+            Events,
+            TimingPoints,
+            Colours,
+            HitObjects,
+            Variables,
+        }
+
+        internal enum LegacySampleBank
+        {
+            None = 0,
+            Normal = 1,
+            Soft = 2,
+            Drum = 3
+        }
+
+        internal enum EventType
+        {
+            Background = 0,
+            Video = 1,
+            Break = 2,
+            Colour = 3,
+            Sprite = 4,
+            Sample = 5,
+            Animation = 6
+        }
+
+        internal enum LegacyOrigins
+        {
+            TopLeft,
+            Centre,
+            CentreLeft,
+            TopRight,
+            BottomCentre,
+            TopCentre,
+            Custom,
+            CentreRight,
+            BottomLeft,
+            BottomRight
+        };
+
+        internal enum StoryLayer
+        {
+            Background = 0,
+            Fail = 1,
+            Pass = 2,
+            Foreground = 3
+        }
+    }
+}

osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs

@@ -0,0 +1,271 @@
+// Copyright (c) 2007-2017 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 System.IO;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Graphics;
+using osu.Framework.IO.File;
+using osu.Game.Storyboards;
+
+namespace osu.Game.Beatmaps.Formats
+{
+    public class LegacyStoryboardDecoder : LegacyDecoder
+    {
+        private Storyboard storyboard;
+
+        private StoryboardSprite storyboardSprite;
+        private CommandTimelineGroup timelineGroup;
+
+        public LegacyStoryboardDecoder()
+        {
+        }
+
+        public LegacyStoryboardDecoder(int beatmapVersion)
+        {
+            BeatmapVersion = beatmapVersion;
+        }
+
+        protected override void ParseStoryboard(StreamReader stream, Storyboard storyboard)
+        {
+            if (stream == null)
+                throw new ArgumentNullException(nameof(stream));
+            if (storyboard == null)
+                throw new ArgumentNullException(nameof(storyboard));
+
+            this.storyboard = storyboard;
+
+            ParseContent(stream);
+        }
+
+        protected override void ProcessSection(Section section, string line)
+        {
+            switch (section)
+            {
+                case Section.Events:
+                    handleEvents(line);
+                    break;
+            }
+        }
+
+        private void handleEvents(string line)
+        {
+            var depth = 0;
+            while (line.StartsWith(" ") || line.StartsWith("_"))
+            {
+                ++depth;
+                line = line.Substring(1);
+            }
+
+            DecodeVariables(ref line);
+
+            string[] split = line.Split(',');
+
+            if (depth == 0)
+            {
+                storyboardSprite = null;
+
+                EventType type;
+                if (!Enum.TryParse(split[0], out type))
+                    throw new InvalidDataException($@"Unknown event type {split[0]}");
+
+                switch (type)
+                {
+                    case EventType.Sprite:
+                        {
+                            var layer = parseLayer(split[1]);
+                            var origin = parseOrigin(split[2]);
+                            var path = cleanFilename(split[3]);
+                            var x = float.Parse(split[4], NumberFormatInfo.InvariantInfo);
+                            var y = float.Parse(split[5], NumberFormatInfo.InvariantInfo);
+                            storyboardSprite = new StoryboardSprite(path, origin, new Vector2(x, y));
+                            storyboard.GetLayer(layer).Add(storyboardSprite);
+                        }
+                        break;
+                    case EventType.Animation:
+                        {
+                            var layer = parseLayer(split[1]);
+                            var origin = parseOrigin(split[2]);
+                            var path = cleanFilename(split[3]);
+                            var x = float.Parse(split[4], NumberFormatInfo.InvariantInfo);
+                            var y = float.Parse(split[5], NumberFormatInfo.InvariantInfo);
+                            var frameCount = int.Parse(split[6]);
+                            var frameDelay = double.Parse(split[7], NumberFormatInfo.InvariantInfo);
+                            var loopType = split.Length > 8 ? (AnimationLoopType)Enum.Parse(typeof(AnimationLoopType), split[8]) : AnimationLoopType.LoopForever;
+                            storyboardSprite = new StoryboardAnimation(path, origin, new Vector2(x, y), frameCount, frameDelay, loopType);
+                            storyboard.GetLayer(layer).Add(storyboardSprite);
+                        }
+                        break;
+                    case EventType.Sample:
+                        {
+                            var time = double.Parse(split[1], CultureInfo.InvariantCulture);
+                            var layer = parseLayer(split[2]);
+                            var path = cleanFilename(split[3]);
+                            var volume = split.Length > 4 ? float.Parse(split[4], CultureInfo.InvariantCulture) : 100;
+                            storyboard.GetLayer(layer).Add(new StoryboardSample(path, time, volume));
+                        }
+                        break;
+                }
+            }
+            else
+            {
+                if (depth < 2)
+                    timelineGroup = storyboardSprite?.TimelineGroup;
+
+                var commandType = split[0];
+                switch (commandType)
+                {
+                    case "T":
+                        {
+                            var triggerName = split[1];
+                            var startTime = split.Length > 2 ? double.Parse(split[2], CultureInfo.InvariantCulture) : double.MinValue;
+                            var endTime = split.Length > 3 ? double.Parse(split[3], CultureInfo.InvariantCulture) : double.MaxValue;
+                            var groupNumber = split.Length > 4 ? int.Parse(split[4]) : 0;
+                            timelineGroup = storyboardSprite?.AddTrigger(triggerName, startTime, endTime, groupNumber);
+                        }
+                        break;
+                    case "L":
+                        {
+                            var startTime = double.Parse(split[1], CultureInfo.InvariantCulture);
+                            var loopCount = int.Parse(split[2]);
+                            timelineGroup = storyboardSprite?.AddLoop(startTime, loopCount);
+                        }
+                        break;
+                    default:
+                        {
+                            if (string.IsNullOrEmpty(split[3]))
+                                split[3] = split[2];
+
+                            var easing = (Easing)int.Parse(split[1]);
+                            var startTime = double.Parse(split[2], CultureInfo.InvariantCulture);
+                            var endTime = double.Parse(split[3], CultureInfo.InvariantCulture);
+
+                            switch (commandType)
+                            {
+                                case "F":
+                                    {
+                                        var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
+                                        var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
+                                        timelineGroup?.Alpha.Add(easing, startTime, endTime, startValue, endValue);
+                                    }
+                                    break;
+                                case "S":
+                                    {
+                                        var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
+                                        var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
+                                        timelineGroup?.Scale.Add(easing, startTime, endTime, new Vector2(startValue), new Vector2(endValue));
+                                    }
+                                    break;
+                                case "V":
+                                    {
+                                        var startX = float.Parse(split[4], CultureInfo.InvariantCulture);
+                                        var startY = float.Parse(split[5], CultureInfo.InvariantCulture);
+                                        var endX = split.Length > 6 ? float.Parse(split[6], CultureInfo.InvariantCulture) : startX;
+                                        var endY = split.Length > 7 ? float.Parse(split[7], CultureInfo.InvariantCulture) : startY;
+                                        timelineGroup?.Scale.Add(easing, startTime, endTime, new Vector2(startX, startY), new Vector2(endX, endY));
+                                    }
+                                    break;
+                                case "R":
+                                    {
+                                        var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
+                                        var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
+                                        timelineGroup?.Rotation.Add(easing, startTime, endTime, MathHelper.RadiansToDegrees(startValue), MathHelper.RadiansToDegrees(endValue));
+                                    }
+                                    break;
+                                case "M":
+                                    {
+                                        var startX = float.Parse(split[4], CultureInfo.InvariantCulture);
+                                        var startY = float.Parse(split[5], CultureInfo.InvariantCulture);
+                                        var endX = split.Length > 6 ? float.Parse(split[6], CultureInfo.InvariantCulture) : startX;
+                                        var endY = split.Length > 7 ? float.Parse(split[7], CultureInfo.InvariantCulture) : startY;
+                                        timelineGroup?.X.Add(easing, startTime, endTime, startX, endX);
+                                        timelineGroup?.Y.Add(easing, startTime, endTime, startY, endY);
+                                    }
+                                    break;
+                                case "MX":
+                                    {
+                                        var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
+                                        var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
+                                        timelineGroup?.X.Add(easing, startTime, endTime, startValue, endValue);
+                                    }
+                                    break;
+                                case "MY":
+                                    {
+                                        var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
+                                        var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
+                                        timelineGroup?.Y.Add(easing, startTime, endTime, startValue, endValue);
+                                    }
+                                    break;
+                                case "C":
+                                    {
+                                        var startRed = float.Parse(split[4], CultureInfo.InvariantCulture);
+                                        var startGreen = float.Parse(split[5], CultureInfo.InvariantCulture);
+                                        var startBlue = float.Parse(split[6], CultureInfo.InvariantCulture);
+                                        var endRed = split.Length > 7 ? float.Parse(split[7], CultureInfo.InvariantCulture) : startRed;
+                                        var endGreen = split.Length > 8 ? float.Parse(split[8], CultureInfo.InvariantCulture) : startGreen;
+                                        var endBlue = split.Length > 9 ? float.Parse(split[9], CultureInfo.InvariantCulture) : startBlue;
+                                        timelineGroup?.Colour.Add(easing, startTime, endTime,
+                                            new Color4(startRed / 255f, startGreen / 255f, startBlue / 255f, 1),
+                                            new Color4(endRed / 255f, endGreen / 255f, endBlue / 255f, 1));
+                                    }
+                                    break;
+                                case "P":
+                                    {
+                                        var type = split[4];
+                                        switch (type)
+                                        {
+                                            case "A":
+                                                timelineGroup?.BlendingMode.Add(easing, startTime, endTime, BlendingMode.Additive, startTime == endTime ? BlendingMode.Additive : BlendingMode.Inherit);
+                                                break;
+                                            case "H":
+                                                timelineGroup?.FlipH.Add(easing, startTime, endTime, true, startTime == endTime);
+                                                break;
+                                            case "V":
+                                                timelineGroup?.FlipV.Add(easing, startTime, endTime, true, startTime == endTime);
+                                                break;
+                                        }
+                                    }
+                                    break;
+                                default:
+                                    throw new InvalidDataException($@"Unknown command type: {commandType}");
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+
+        private string parseLayer(string value) => Enum.Parse(typeof(StoryLayer), value).ToString();
+
+        private Anchor parseOrigin(string value)
+        {
+            var origin = (LegacyOrigins)Enum.Parse(typeof(LegacyOrigins), value);
+            switch (origin)
+            {
+                case LegacyOrigins.TopLeft:
+                    return Anchor.TopLeft;
+                case LegacyOrigins.TopCentre:
+                    return Anchor.TopCentre;
+                case LegacyOrigins.TopRight:
+                    return Anchor.TopRight;
+                case LegacyOrigins.CentreLeft:
+                    return Anchor.CentreLeft;
+                case LegacyOrigins.Centre:
+                    return Anchor.Centre;
+                case LegacyOrigins.CentreRight:
+                    return Anchor.CentreRight;
+                case LegacyOrigins.BottomLeft:
+                    return Anchor.BottomLeft;
+                case LegacyOrigins.BottomCentre:
+                    return Anchor.BottomCentre;
+                case LegacyOrigins.BottomRight:
+                    return Anchor.BottomRight;
+            }
+            throw new InvalidDataException($@"Unknown origin: {value}");
+        }
+
+        private string cleanFilename(string path) => FileSafety.PathStandardise(path.Trim('\"'));
+    }
+}

osu.Game/Beatmaps/Formats/OsuLegacyDecoder.cs

@@ -1,781 +0,0 @@
-// Copyright (c) 2007-2017 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.Globalization;
-using System.IO;
-using OpenTK.Graphics;
-using osu.Game.Beatmaps.Timing;
-using osu.Game.Beatmaps.Legacy;
-using osu.Game.Rulesets.Objects.Legacy;
-using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Storyboards;
-using OpenTK;
-using osu.Framework.Graphics;
-using osu.Framework.IO.File;
-
-namespace osu.Game.Beatmaps.Formats
-{
-    public class OsuLegacyDecoder : BeatmapDecoder
-    {
-        public static void Register()
-        {
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v14");
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v13");
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v12");
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v11");
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v10");
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v9");
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v8");
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v7");
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v6");
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v5");
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v4");
-            AddDecoder<OsuLegacyDecoder>(@"osu file format v3");
-            // TODO: differences between versions
-        }
-
-        private ConvertHitObjectParser parser;
-
-        private readonly Dictionary<string, string> variables = new Dictionary<string, string>();
-
-        private LegacySampleBank defaultSampleBank;
-        private int defaultSampleVolume = 100;
-
-        private readonly int beatmapVersion;
-
-        public OsuLegacyDecoder()
-        {
-        }
-
-        public OsuLegacyDecoder(string header)
-        {
-            beatmapVersion = int.Parse(header.Substring(17));
-        }
-
-        private enum Section
-        {
-            None,
-            General,
-            Editor,
-            Metadata,
-            Difficulty,
-            Events,
-            TimingPoints,
-            Colours,
-            HitObjects,
-            Variables,
-        }
-
-        private void handleGeneral(Beatmap beatmap, string line)
-        {
-            if (beatmap == null)
-                throw new ArgumentNullException(nameof(beatmap));
-            if (line == null)
-                throw new ArgumentNullException(nameof(line));
-
-            var pair = splitKeyVal(line, ':');
-
-            var metadata = beatmap.BeatmapInfo.Metadata;
-            switch (pair.Key)
-            {
-                case @"AudioFilename":
-                    metadata.AudioFile = pair.Value;
-                    break;
-                case @"AudioLeadIn":
-                    beatmap.BeatmapInfo.AudioLeadIn = int.Parse(pair.Value);
-                    break;
-                case @"PreviewTime":
-                    metadata.PreviewTime = int.Parse(pair.Value);
-                    break;
-                case @"Countdown":
-                    beatmap.BeatmapInfo.Countdown = int.Parse(pair.Value) == 1;
-                    break;
-                case @"SampleSet":
-                    defaultSampleBank = (LegacySampleBank)Enum.Parse(typeof(LegacySampleBank), pair.Value);
-                    break;
-                case @"SampleVolume":
-                    defaultSampleVolume = int.Parse(pair.Value);
-                    break;
-                case @"StackLeniency":
-                    beatmap.BeatmapInfo.StackLeniency = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
-                    break;
-                case @"Mode":
-                    beatmap.BeatmapInfo.RulesetID = int.Parse(pair.Value);
-
-                    switch (beatmap.BeatmapInfo.RulesetID)
-                    {
-                        case 0:
-                            parser = new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser();
-                            break;
-                        case 1:
-                            parser = new Rulesets.Objects.Legacy.Taiko.ConvertHitObjectParser();
-                            break;
-                        case 2:
-                            parser = new Rulesets.Objects.Legacy.Catch.ConvertHitObjectParser();
-                            break;
-                        case 3:
-                            parser = new Rulesets.Objects.Legacy.Mania.ConvertHitObjectParser();
-                            break;
-                    }
-                    break;
-                case @"LetterboxInBreaks":
-                    beatmap.BeatmapInfo.LetterboxInBreaks = int.Parse(pair.Value) == 1;
-                    break;
-                case @"SpecialStyle":
-                    beatmap.BeatmapInfo.SpecialStyle = int.Parse(pair.Value) == 1;
-                    break;
-                case @"WidescreenStoryboard":
-                    beatmap.BeatmapInfo.WidescreenStoryboard = int.Parse(pair.Value) == 1;
-                    break;
-            }
-        }
-
-        private void handleEditor(Beatmap beatmap, string line)
-        {
-            if (beatmap == null)
-                throw new ArgumentNullException(nameof(beatmap));
-            if (line == null)
-                throw new ArgumentNullException(nameof(line));
-
-            var pair = splitKeyVal(line, ':');
-
-            switch (pair.Key)
-            {
-                case @"Bookmarks":
-                    beatmap.BeatmapInfo.StoredBookmarks = pair.Value;
-                    break;
-                case @"DistanceSpacing":
-                    beatmap.BeatmapInfo.DistanceSpacing = double.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
-                    break;
-                case @"BeatDivisor":
-                    beatmap.BeatmapInfo.BeatDivisor = int.Parse(pair.Value);
-                    break;
-                case @"GridSize":
-                    beatmap.BeatmapInfo.GridSize = int.Parse(pair.Value);
-                    break;
-                case @"TimelineZoom":
-                    beatmap.BeatmapInfo.TimelineZoom = double.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
-                    break;
-            }
-        }
-
-        private void handleMetadata(Beatmap beatmap, string line)
-        {
-            if (beatmap == null)
-                throw new ArgumentNullException(nameof(beatmap));
-            if (line == null)
-                throw new ArgumentNullException(nameof(line));
-
-            var pair = splitKeyVal(line, ':');
-
-            var metadata = beatmap.BeatmapInfo.Metadata;
-            switch (pair.Key)
-            {
-                case @"Title":
-                    metadata.Title = pair.Value;
-                    break;
-                case @"TitleUnicode":
-                    metadata.TitleUnicode = pair.Value;
-                    break;
-                case @"Artist":
-                    metadata.Artist = pair.Value;
-                    break;
-                case @"ArtistUnicode":
-                    metadata.ArtistUnicode = pair.Value;
-                    break;
-                case @"Creator":
-                    metadata.AuthorString = pair.Value;
-                    break;
-                case @"Version":
-                    beatmap.BeatmapInfo.Version = pair.Value;
-                    break;
-                case @"Source":
-                    beatmap.BeatmapInfo.Metadata.Source = pair.Value;
-                    break;
-                case @"Tags":
-                    beatmap.BeatmapInfo.Metadata.Tags = pair.Value;
-                    break;
-                case @"BeatmapID":
-                    beatmap.BeatmapInfo.OnlineBeatmapID = int.Parse(pair.Value);
-                    break;
-                case @"BeatmapSetID":
-                    beatmap.BeatmapInfo.OnlineBeatmapSetID = int.Parse(pair.Value);
-                    metadata.OnlineBeatmapSetID = int.Parse(pair.Value);
-                    break;
-            }
-        }
-
-        private void handleDifficulty(Beatmap beatmap, string line)
-        {
-            if (beatmap == null)
-                throw new ArgumentNullException(nameof(beatmap));
-            if (line == null)
-                throw new ArgumentNullException(nameof(line));
-
-            var pair = splitKeyVal(line, ':');
-
-            var difficulty = beatmap.BeatmapInfo.BaseDifficulty;
-            switch (pair.Key)
-            {
-                case @"HPDrainRate":
-                    difficulty.DrainRate = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
-                    break;
-                case @"CircleSize":
-                    difficulty.CircleSize = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
-                    break;
-                case @"OverallDifficulty":
-                    difficulty.OverallDifficulty = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
-                    break;
-                case @"ApproachRate":
-                    difficulty.ApproachRate = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
-                    break;
-                case @"SliderMultiplier":
-                    difficulty.SliderMultiplier = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
-                    break;
-                case @"SliderTickRate":
-                    difficulty.SliderTickRate = float.Parse(pair.Value, NumberFormatInfo.InvariantInfo);
-                    break;
-            }
-        }
-
-        /// <summary>
-        /// Decodes any beatmap variables present in a line into their real values.
-        /// </summary>
-        /// <param name="line">The line which may contains variables.</param>
-        private void decodeVariables(ref string line)
-        {
-            if (line == null)
-                throw new ArgumentNullException(nameof(line));
-
-            while (line.IndexOf('$') >= 0)
-            {
-                string origLine = line;
-                string[] split = line.Split(',');
-                for (int i = 0; i < split.Length; i++)
-                {
-                    var item = split[i];
-                    if (item.StartsWith("$") && variables.ContainsKey(item))
-                        split[i] = variables[item];
-                }
-
-                line = string.Join(",", split);
-                if (line == origLine) break;
-            }
-        }
-
-        private void handleEvents(Beatmap beatmap, string line, ref StoryboardSprite storyboardSprite, ref CommandTimelineGroup timelineGroup)
-        {
-            if (line == null)
-                throw new ArgumentNullException(nameof(line));
-            if (beatmap == null)
-                throw new ArgumentNullException(nameof(beatmap));
-
-            var depth = 0;
-            while (line.StartsWith(" ") || line.StartsWith("_"))
-            {
-                ++depth;
-                line = line.Substring(1);
-            }
-
-            decodeVariables(ref line);
-
-            string[] split = line.Split(',');
-
-            if (depth == 0)
-            {
-                storyboardSprite = null;
-
-                EventType type;
-                if (!Enum.TryParse(split[0], out type))
-                    throw new InvalidDataException($@"Unknown event type {split[0]}");
-
-                switch (type)
-                {
-                    case EventType.Video:
-                    case EventType.Background:
-                        string filename = split[2].Trim('"');
-
-                        if (type == EventType.Background)
-                            beatmap.BeatmapInfo.Metadata.BackgroundFile = filename;
-
-                        break;
-                    case EventType.Break:
-                        var breakEvent = new BreakPeriod
-                        {
-                            StartTime = double.Parse(split[1], NumberFormatInfo.InvariantInfo),
-                            EndTime = double.Parse(split[2], NumberFormatInfo.InvariantInfo)
-                        };
-
-                        if (!breakEvent.HasEffect)
-                            return;
-
-                        beatmap.Breaks.Add(breakEvent);
-                        break;
-                    case EventType.Sprite:
-                        {
-                            var layer = parseLayer(split[1]);
-                            var origin = parseOrigin(split[2]);
-                            var path = cleanFilename(split[3]);
-                            var x = float.Parse(split[4], NumberFormatInfo.InvariantInfo);
-                            var y = float.Parse(split[5], NumberFormatInfo.InvariantInfo);
-                            storyboardSprite = new StoryboardSprite(path, origin, new Vector2(x, y));
-                            beatmap.Storyboard.GetLayer(layer).Add(storyboardSprite);
-                        }
-                        break;
-                    case EventType.Animation:
-                        {
-                            var layer = parseLayer(split[1]);
-                            var origin = parseOrigin(split[2]);
-                            var path = cleanFilename(split[3]);
-                            var x = float.Parse(split[4], NumberFormatInfo.InvariantInfo);
-                            var y = float.Parse(split[5], NumberFormatInfo.InvariantInfo);
-                            var frameCount = int.Parse(split[6]);
-                            var frameDelay = double.Parse(split[7], NumberFormatInfo.InvariantInfo);
-                            var loopType = split.Length > 8 ? (AnimationLoopType)Enum.Parse(typeof(AnimationLoopType), split[8]) : AnimationLoopType.LoopForever;
-                            storyboardSprite = new StoryboardAnimation(path, origin, new Vector2(x, y), frameCount, frameDelay, loopType);
-                            beatmap.Storyboard.GetLayer(layer).Add(storyboardSprite);
-                        }
-                        break;
-                    case EventType.Sample:
-                        {
-                            var time = double.Parse(split[1], CultureInfo.InvariantCulture);
-                            var layer = parseLayer(split[2]);
-                            var path = cleanFilename(split[3]);
-                            var volume = split.Length > 4 ? float.Parse(split[4], CultureInfo.InvariantCulture) : 100;
-                            beatmap.Storyboard.GetLayer(layer).Add(new StoryboardSample(path, time, volume));
-                        }
-                        break;
-                }
-            }
-            else
-            {
-                if (depth < 2)
-                    timelineGroup = storyboardSprite?.TimelineGroup;
-
-                var commandType = split[0];
-                switch (commandType)
-                {
-                    case "T":
-                        {
-                            var triggerName = split[1];
-                            var startTime = split.Length > 2 ? double.Parse(split[2], CultureInfo.InvariantCulture) : double.MinValue;
-                            var endTime = split.Length > 3 ? double.Parse(split[3], CultureInfo.InvariantCulture) : double.MaxValue;
-                            var groupNumber = split.Length > 4 ? int.Parse(split[4]) : 0;
-                            timelineGroup = storyboardSprite?.AddTrigger(triggerName, startTime, endTime, groupNumber);
-                        }
-                        break;
-                    case "L":
-                        {
-                            var startTime = double.Parse(split[1], CultureInfo.InvariantCulture);
-                            var loopCount = int.Parse(split[2]);
-                            timelineGroup = storyboardSprite?.AddLoop(startTime, loopCount);
-                        }
-                        break;
-                    default:
-                        {
-                            if (string.IsNullOrEmpty(split[3]))
-                                split[3] = split[2];
-
-                            var easing = (Easing)int.Parse(split[1]);
-                            var startTime = double.Parse(split[2], CultureInfo.InvariantCulture);
-                            var endTime = double.Parse(split[3], CultureInfo.InvariantCulture);
-
-                            switch (commandType)
-                            {
-                                case "F":
-                                    {
-                                        var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                        var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
-                                        timelineGroup?.Alpha.Add(easing, startTime, endTime, startValue, endValue);
-                                    }
-                                    break;
-                                case "S":
-                                    {
-                                        var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                        var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
-                                        timelineGroup?.Scale.Add(easing, startTime, endTime, new Vector2(startValue), new Vector2(endValue));
-                                    }
-                                    break;
-                                case "V":
-                                    {
-                                        var startX = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                        var startY = float.Parse(split[5], CultureInfo.InvariantCulture);
-                                        var endX = split.Length > 6 ? float.Parse(split[6], CultureInfo.InvariantCulture) : startX;
-                                        var endY = split.Length > 7 ? float.Parse(split[7], CultureInfo.InvariantCulture) : startY;
-                                        timelineGroup?.Scale.Add(easing, startTime, endTime, new Vector2(startX, startY), new Vector2(endX, endY));
-                                    }
-                                    break;
-                                case "R":
-                                    {
-                                        var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                        var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
-                                        timelineGroup?.Rotation.Add(easing, startTime, endTime, MathHelper.RadiansToDegrees(startValue), MathHelper.RadiansToDegrees(endValue));
-                                    }
-                                    break;
-                                case "M":
-                                    {
-                                        var startX = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                        var startY = float.Parse(split[5], CultureInfo.InvariantCulture);
-                                        var endX = split.Length > 6 ? float.Parse(split[6], CultureInfo.InvariantCulture) : startX;
-                                        var endY = split.Length > 7 ? float.Parse(split[7], CultureInfo.InvariantCulture) : startY;
-                                        timelineGroup?.X.Add(easing, startTime, endTime, startX, endX);
-                                        timelineGroup?.Y.Add(easing, startTime, endTime, startY, endY);
-                                    }
-                                    break;
-                                case "MX":
-                                    {
-                                        var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                        var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
-                                        timelineGroup?.X.Add(easing, startTime, endTime, startValue, endValue);
-                                    }
-                                    break;
-                                case "MY":
-                                    {
-                                        var startValue = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                        var endValue = split.Length > 5 ? float.Parse(split[5], CultureInfo.InvariantCulture) : startValue;
-                                        timelineGroup?.Y.Add(easing, startTime, endTime, startValue, endValue);
-                                    }
-                                    break;
-                                case "C":
-                                    {
-                                        var startRed = float.Parse(split[4], CultureInfo.InvariantCulture);
-                                        var startGreen = float.Parse(split[5], CultureInfo.InvariantCulture);
-                                        var startBlue = float.Parse(split[6], CultureInfo.InvariantCulture);
-                                        var endRed = split.Length > 7 ? float.Parse(split[7], CultureInfo.InvariantCulture) : startRed;
-                                        var endGreen = split.Length > 8 ? float.Parse(split[8], CultureInfo.InvariantCulture) : startGreen;
-                                        var endBlue = split.Length > 9 ? float.Parse(split[9], CultureInfo.InvariantCulture) : startBlue;
-                                        timelineGroup?.Colour.Add(easing, startTime, endTime,
-                                            new Color4(startRed / 255f, startGreen / 255f, startBlue / 255f, 1),
-                                            new Color4(endRed / 255f, endGreen / 255f, endBlue / 255f, 1));
-                                    }
-                                    break;
-                                case "P":
-                                    {
-                                        var type = split[4];
-                                        switch (type)
-                                        {
-                                            case "A": timelineGroup?.BlendingMode.Add(easing, startTime, endTime, BlendingMode.Additive, startTime == endTime ? BlendingMode.Additive : BlendingMode.Inherit); break;
-                                            case "H": timelineGroup?.FlipH.Add(easing, startTime, endTime, true, startTime == endTime); break;
-                                            case "V": timelineGroup?.FlipV.Add(easing, startTime, endTime, true, startTime == endTime); break;
-                                        }
-                                    }
-                                    break;
-                                default:
-                                    throw new InvalidDataException($@"Unknown command type: {commandType}");
-                            }
-                        }
-                        break;
-                }
-            }
-        }
-
-        private static string cleanFilename(string path)
-            => FileSafety.PathStandardise(path.Trim('\"'));
-
-        private static Anchor parseOrigin(string value)
-        {
-            var origin = (LegacyOrigins)Enum.Parse(typeof(LegacyOrigins), value);
-            switch (origin)
-            {
-                case LegacyOrigins.TopLeft: return Anchor.TopLeft;
-                case LegacyOrigins.TopCentre: return Anchor.TopCentre;
-                case LegacyOrigins.TopRight: return Anchor.TopRight;
-                case LegacyOrigins.CentreLeft: return Anchor.CentreLeft;
-                case LegacyOrigins.Centre: return Anchor.Centre;
-                case LegacyOrigins.CentreRight: return Anchor.CentreRight;
-                case LegacyOrigins.BottomLeft: return Anchor.BottomLeft;
-                case LegacyOrigins.BottomCentre: return Anchor.BottomCentre;
-                case LegacyOrigins.BottomRight: return Anchor.BottomRight;
-            }
-            throw new InvalidDataException($@"Unknown origin: {value}");
-        }
-
-        private static string parseLayer(string value)
-            => Enum.Parse(typeof(StoryLayer), value).ToString();
-
-        private void handleTimingPoints(Beatmap beatmap, string line)
-        {
-            if (beatmap == null)
-                throw new ArgumentNullException(nameof(beatmap));
-            if (line == null)
-                throw new ArgumentNullException(nameof(line));
-
-            string[] split = line.Split(',');
-
-            double time = double.Parse(split[0].Trim(), NumberFormatInfo.InvariantInfo);
-            double beatLength = double.Parse(split[1].Trim(), NumberFormatInfo.InvariantInfo);
-            double speedMultiplier = beatLength < 0 ? 100.0 / -beatLength : 1;
-
-            TimeSignatures timeSignature = TimeSignatures.SimpleQuadruple;
-            if (split.Length >= 3)
-                timeSignature = split[2][0] == '0' ? TimeSignatures.SimpleQuadruple : (TimeSignatures)int.Parse(split[2]);
-
-            LegacySampleBank sampleSet = defaultSampleBank;
-            if (split.Length >= 4)
-                sampleSet = (LegacySampleBank)int.Parse(split[3]);
-
-            //SampleBank sampleBank = SampleBank.Default;
-            //if (split.Length >= 5)
-            //    sampleBank = (SampleBank)int.Parse(split[4]);
-
-            int sampleVolume = defaultSampleVolume;
-            if (split.Length >= 6)
-                sampleVolume = int.Parse(split[5]);
-
-            bool timingChange = true;
-            if (split.Length >= 7)
-                timingChange = split[6][0] == '1';
-
-            bool kiaiMode = false;
-            bool omitFirstBarSignature = false;
-            if (split.Length >= 8)
-            {
-                int effectFlags = int.Parse(split[7]);
-                kiaiMode = (effectFlags & 1) > 0;
-                omitFirstBarSignature = (effectFlags & 8) > 0;
-            }
-
-            string stringSampleSet = sampleSet.ToString().ToLower();
-            if (stringSampleSet == @"none")
-                stringSampleSet = @"normal";
-
-            DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(time);
-            SoundControlPoint soundPoint = beatmap.ControlPointInfo.SoundPointAt(time);
-            EffectControlPoint effectPoint = beatmap.ControlPointInfo.EffectPointAt(time);
-
-            if (timingChange)
-            {
-                beatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint
-                {
-                    Time = time,
-                    BeatLength = beatLength,
-                    TimeSignature = timeSignature
-                });
-            }
-
-            if (speedMultiplier != difficultyPoint.SpeedMultiplier)
-            {
-                beatmap.ControlPointInfo.DifficultyPoints.RemoveAll(x => x.Time == time);
-                beatmap.ControlPointInfo.DifficultyPoints.Add(new DifficultyControlPoint
-                {
-                    Time = time,
-                    SpeedMultiplier = speedMultiplier
-                });
-            }
-
-            if (stringSampleSet != soundPoint.SampleBank || sampleVolume != soundPoint.SampleVolume)
-            {
-                beatmap.ControlPointInfo.SoundPoints.Add(new SoundControlPoint
-                {
-                    Time = time,
-                    SampleBank = stringSampleSet,
-                    SampleVolume = sampleVolume
-                });
-            }
-
-            if (kiaiMode != effectPoint.KiaiMode || omitFirstBarSignature != effectPoint.OmitFirstBarLine)
-            {
-                beatmap.ControlPointInfo.EffectPoints.Add(new EffectControlPoint
-                {
-                    Time = time,
-                    KiaiMode = kiaiMode,
-                    OmitFirstBarLine = omitFirstBarSignature
-                });
-            }
-        }
-
-        private void handleColours(Beatmap beatmap, string line, ref bool hasCustomColours)
-        {
-            if (beatmap == null)
-                throw new ArgumentNullException(nameof(beatmap));
-            if (line == null)
-                throw new ArgumentNullException(nameof(line));
-
-            var pair = splitKeyVal(line, ':');
-
-            string[] split = pair.Value.Split(',');
-
-            if (split.Length != 3)
-                throw new InvalidOperationException($@"Color specified in incorrect format (should be R,G,B): {pair.Value}");
-
-            byte r, g, b;
-            if (!byte.TryParse(split[0], out r) || !byte.TryParse(split[1], out g) || !byte.TryParse(split[2], out b))
-                throw new InvalidOperationException(@"Color must be specified with 8-bit integer components");
-
-            if (!hasCustomColours)
-            {
-                beatmap.ComboColors.Clear();
-                hasCustomColours = true;
-            }
-
-            // Note: the combo index specified in the beatmap is discarded
-            if (pair.Key.StartsWith(@"Combo"))
-            {
-                beatmap.ComboColors.Add(new Color4
-                {
-                    R = r / 255f,
-                    G = g / 255f,
-                    B = b / 255f,
-                    A = 1f,
-                });
-            }
-        }
-
-        private void handleVariables(string line)
-        {
-            if (line == null)
-                throw new ArgumentNullException(nameof(line));
-
-            var pair = splitKeyVal(line, '=');
-            variables[pair.Key] = pair.Value;
-        }
-
-        protected override Beatmap ParseFile(StreamReader stream)
-        {
-            return new LegacyBeatmap(base.ParseFile(stream));
-        }
-
-        public override Beatmap Decode(StreamReader stream)
-        {
-            return new LegacyBeatmap(base.Decode(stream));
-        }
-
-        protected override void ParseFile(StreamReader stream, Beatmap beatmap)
-        {
-            if (beatmap == null)
-                throw new ArgumentNullException(nameof(beatmap));
-            if (stream == null)
-                throw new ArgumentNullException(nameof(stream));
-
-            beatmap.BeatmapInfo.BeatmapVersion = beatmapVersion;
-
-            Section section = Section.None;
-            bool hasCustomColours = false;
-            StoryboardSprite storyboardSprite = null;
-            CommandTimelineGroup timelineGroup = null;
-
-            string line;
-            while ((line = stream.ReadLine()) != null)
-            {
-                if (string.IsNullOrWhiteSpace(line))
-                    continue;
-
-                if (line.StartsWith("//"))
-                    continue;
-
-                if (line.StartsWith(@"osu file format v"))
-                {
-                    beatmap.BeatmapInfo.BeatmapVersion = int.Parse(line.Substring(17));
-                    continue;
-                }
-
-                if (line.StartsWith(@"[") && line.EndsWith(@"]"))
-                {
-                    if (!Enum.TryParse(line.Substring(1, line.Length - 2), out section))
-                        throw new InvalidDataException($@"Unknown osu section {line}");
-                    continue;
-                }
-
-                switch (section)
-                {
-                    case Section.General:
-                        handleGeneral(beatmap, line);
-                        break;
-                    case Section.Editor:
-                        handleEditor(beatmap, line);
-                        break;
-                    case Section.Metadata:
-                        handleMetadata(beatmap, line);
-                        break;
-                    case Section.Difficulty:
-                        handleDifficulty(beatmap, line);
-                        break;
-                    case Section.Events:
-                        handleEvents(beatmap, line, ref storyboardSprite, ref timelineGroup);
-                        break;
-                    case Section.TimingPoints:
-                        handleTimingPoints(beatmap, line);
-                        break;
-                    case Section.Colours:
-                        handleColours(beatmap, line, ref hasCustomColours);
-                        break;
-                    case Section.HitObjects:
-
-                        // If the ruleset wasn't specified, assume the osu!standard ruleset.
-                        if (parser == null)
-                            parser = new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser();
-
-                        var obj = parser.Parse(line);
-
-                        if (obj != null)
-                            beatmap.HitObjects.Add(obj);
-
-                        break;
-                    case Section.Variables:
-                        handleVariables(line);
-                        break;
-                }
-            }
-
-            foreach (var hitObject in beatmap.HitObjects)
-                hitObject.ApplyDefaults(beatmap.ControlPointInfo, beatmap.BeatmapInfo.BaseDifficulty);
-        }
-
-        private KeyValuePair<string, string> splitKeyVal(string line, char separator)
-        {
-            if (line == null)
-                throw new ArgumentNullException(nameof(line));
-
-            var split = line.Trim().Split(new[] { separator }, 2);
-
-            return new KeyValuePair<string, string>
-            (
-                split[0].Trim(),
-                split.Length > 1 ? split[1].Trim() : string.Empty
-            );
-        }
-
-        internal enum LegacySampleBank
-        {
-            None = 0,
-            Normal = 1,
-            Soft = 2,
-            Drum = 3
-        }
-
-        internal enum EventType
-        {
-            Background = 0,
-            Video = 1,
-            Break = 2,
-            Colour = 3,
-            Sprite = 4,
-            Sample = 5,
-            Animation = 6
-        }
-
-        internal enum LegacyOrigins
-        {
-            TopLeft,
-            Centre,
-            CentreLeft,
-            TopRight,
-            BottomCentre,
-            TopCentre,
-            Custom,
-            CentreRight,
-            BottomLeft,
-            BottomRight
-        };
-
-        internal enum StoryLayer
-        {
-            Background = 0,
-            Fail = 1,
-            Pass = 2,
-            Foreground = 3
-        }
-    }
-}

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -9,6 +9,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using osu.Game.Storyboards;
 
 namespace osu.Game.Beatmaps
 {
@@ -34,14 +35,16 @@ namespace osu.Game.Beatmaps
             background = new AsyncLazy<Texture>(populateBackground, b => b == null || !b.IsDisposed);
             track = new AsyncLazy<Track>(populateTrack);
             waveform = new AsyncLazy<Waveform>(populateWaveform);
+            storyboard = new AsyncLazy<Storyboard>(populateStoryboard);
         }
 
         protected abstract Beatmap GetBeatmap();
         protected abstract Texture GetBackground();
         protected abstract Track GetTrack();
         protected virtual Waveform GetWaveform() => new Waveform();
+        protected virtual Storyboard GetStoryboard() => new Storyboard();
 
-        public bool BeatmapLoaded => beatmap.IsValueCreated;
+        public bool BeatmapLoaded => beatmap.IsResultAvailable;
         public Beatmap Beatmap => beatmap.Value.Result;
         public async Task<Beatmap> GetBeatmapAsync() => await beatmap.Value;
 
@@ -57,14 +60,14 @@ namespace osu.Game.Beatmaps
             return b;
         }
 
-        public bool BackgroundLoaded => background.IsValueCreated;
+        public bool BackgroundLoaded => background.IsResultAvailable;
         public Texture Background => background.Value.Result;
         public async Task<Texture> GetBackgroundAsync() => await background.Value;
         private AsyncLazy<Texture> background;
 
         private Texture populateBackground() => GetBackground();
 
-        public bool TrackLoaded => track.IsValueCreated;
+        public bool TrackLoaded => track.IsResultAvailable;
         public Track Track => track.Value.Result;
         public async Task<Track> GetTrackAsync() => await track.Value;
         private AsyncLazy<Track> track;
@@ -77,19 +80,26 @@ namespace osu.Game.Beatmaps
             return t;
         }
 
-        public bool WaveformLoaded => waveform.IsValueCreated;
+        public bool WaveformLoaded => waveform.IsResultAvailable;
         public Waveform Waveform => waveform.Value.Result;
         public async Task<Waveform> GetWaveformAsync() => await waveform.Value;
         private readonly AsyncLazy<Waveform> waveform;
 
         private Waveform populateWaveform() => GetWaveform();
 
+        public bool StoryboardLoaded => storyboard.IsResultAvailable;
+        public Storyboard Storyboard => storyboard.Value.Result;
+        public async Task<Storyboard> GetStoryboardAsync() => await storyboard.Value;
+        private readonly AsyncLazy<Storyboard> storyboard;
+
+        private Storyboard populateStoryboard() => GetStoryboard();
+
         public void TransferTo(WorkingBeatmap other)
         {
-            if (track.IsValueCreated && Track != null && BeatmapInfo.AudioEquals(other.BeatmapInfo))
+            if (track.IsResultAvailable && Track != null && BeatmapInfo.AudioEquals(other.BeatmapInfo))
                 other.track = track;
 
-            if (background.IsValueCreated && Background != null && BeatmapInfo.BackgroundEquals(other.BeatmapInfo))
+            if (background.IsResultAvailable && Background != null && BeatmapInfo.BackgroundEquals(other.BeatmapInfo))
                 other.background = background;
         }
 
@@ -97,6 +107,7 @@ namespace osu.Game.Beatmaps
         {
             if (BackgroundLoaded) Background?.Dispose();
             if (WaveformLoaded) Waveform?.Dispose();
+            if (StoryboardLoaded) Storyboard?.Dispose();
         }
 
         /// <summary>
@@ -107,7 +118,7 @@ namespace osu.Game.Beatmaps
 
         private void applyRateAdjustments(Track t = null)
         {
-            if (t == null && track.IsValueCreated) t = Track;
+            if (t == null && track.IsResultAvailable) t = Track;
             if (t == null) return;
 
             t.ResetSpeedAdjustments();
@@ -128,23 +139,23 @@ namespace osu.Game.Beatmaps
                 this.valueFactory = valueFactory;
                 this.stillValidFunction = stillValidFunction;
 
-                init();
+                recreate();
             }
 
             public void Recycle()
             {
-                if (!IsValueCreated) return;
+                if (!IsResultAvailable) return;
 
                 (lazy.Value.Result as IDisposable)?.Dispose();
-                init();
+                recreate();
             }
 
-            public bool IsValueCreated
+            public bool IsResultAvailable
             {
                 get
                 {
-                    ensureValid();
+                    recreateIfInvalid();
-                    return lazy.IsValueCreated;
+                    return lazy.Value.IsCompleted;
                 }
             }
 
@@ -152,24 +163,28 @@ namespace osu.Game.Beatmaps
             {
                 get
                 {
-                    ensureValid();
+                    recreateIfInvalid();
                     return lazy.Value;
                 }
             }
 
-            private void ensureValid()
+            private void recreateIfInvalid()
             {
                 lock (initLock)
                 {
-                    if (!lazy.IsValueCreated || (stillValidFunction?.Invoke(lazy.Value.Result) ?? true)) return;
+                    if (!lazy.IsValueCreated || !lazy.Value.IsCompleted)
-                    init();
+                        // we have not yet been initialised or haven't run the task.
+                        return;
+
+                    if (stillValidFunction?.Invoke(lazy.Value.Result) ?? true)
+                        // we are still in a valid state.
+                        return;
+
+                    recreate();
                 }
             }
 
-            private void init()
+            private void recreate() => lazy = new Lazy<Task<T>>(() => Task.Run(valueFactory));
-            {
-                lazy = new Lazy<Task<T>>(() => Task.Run(valueFactory));
-            }
         }
     }
 }

osu.Game/Input/Bindings/DatabasedKeyBindingInputManager.cs

@@ -14,7 +14,7 @@ namespace osu.Game.Input.Bindings
     /// A KeyBindingInputManager with a database backing for custom overrides.
     /// </summary>
     /// <typeparam name="T">The type of the custom action.</typeparam>
-    public abstract class DatabasedKeyBindingInputManager<T> : KeyBindingInputManager<T>
+    public class DatabasedKeyBindingInputManager<T> : KeyBindingContainer<T>
         where T : struct
     {
         private readonly RulesetInfo ruleset;
@@ -31,7 +31,7 @@ namespace osu.Game.Input.Bindings
         /// <param name="ruleset">A reference to identify the current <see cref="Ruleset"/>. Used to lookup mappings. Null for global mappings.</param>
         /// <param name="variant">An optional variant for the specified <see cref="Ruleset"/>. Used when a ruleset has more than one possible keyboard layouts.</param>
         /// <param name="simultaneousMode">Specify how to deal with multiple matches of <see cref="KeyCombination"/>s and <see cref="T"/>s.</param>
-        protected DatabasedKeyBindingInputManager(RulesetInfo ruleset = null, int? variant = null, SimultaneousBindingMode simultaneousMode = SimultaneousBindingMode.None)
+        public DatabasedKeyBindingInputManager(RulesetInfo ruleset = null, int? variant = null, SimultaneousBindingMode simultaneousMode = SimultaneousBindingMode.None)
             : base(simultaneousMode)
         {
             this.ruleset = ruleset;

osu.Game/Input/KeyBindingStore.cs

@@ -27,7 +27,7 @@ namespace osu.Game.Input
             }
         }
 
-        public void Register(KeyBindingInputManager manager) => insertDefaults(manager.DefaultKeyBindings);
+        public void Register(KeyBindingContainer manager) => insertDefaults(manager.DefaultKeyBindings);
 
         private void insertDefaults(IEnumerable<KeyBinding> defaults, int? rulesetId = null, int? variant = null)
         {

osu.Game/Overlays/BeatmapSet/DownloadButton.cs

@@ -14,10 +14,10 @@ namespace osu.Game.Overlays.BeatmapSet
         public DownloadButton(string title, string subtitle)
         {
             Width = 120;
-            RelativeSizeAxes = Axes.Y;
 
-            Child = new Container
+            Add(new Container
             {
+                Depth = -1,
                 RelativeSizeAxes = Axes.Both,
                 Padding = new MarginPadding { Horizontal = 10 },
                 Children = new Drawable[]
@@ -53,7 +53,7 @@ namespace osu.Game.Overlays.BeatmapSet
                         Margin = new MarginPadding { Right = 5 },
                     },
                 },
-            };
+            });
         }
     }
 }

osu.Game/Overlays/BeatmapSet/FavouriteButton.cs

@@ -1,6 +1,7 @@
 // Copyright (c) 2007-2017 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.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -15,13 +16,12 @@ namespace osu.Game.Overlays.BeatmapSet
     {
         public readonly Bindable<bool> Favourited = new Bindable<bool>();
 
-        public FavouriteButton()
+        [BackgroundDependencyLoader]
+        private void load()
         {
-            RelativeSizeAxes = Axes.Y;
-
             Container pink;
             SpriteIcon icon;
-            Children = new Drawable[]
+            AddRange(new Drawable[]
             {
                 pink = new Container
                 {
@@ -51,7 +51,7 @@ namespace osu.Game.Overlays.BeatmapSet
                     Size = new Vector2(18),
                     Shadow = false,
                 },
-            };
+            });
 
             Favourited.ValueChanged += value =>
             {

osu.Game/Overlays/BeatmapSet/HeaderButton.cs

@@ -2,44 +2,27 @@
 // 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.Graphics.Shapes;
 using osu.Game.Graphics;
-using osu.Game.Graphics.Backgrounds;
+using osu.Game.Graphics.UserInterface;
-using osu.Game.Graphics.Containers;
+using osu.Framework.Allocation;
 
 namespace osu.Game.Overlays.BeatmapSet
 {
-    public class HeaderButton : OsuClickableContainer
+    public class HeaderButton : TriangleButton
     {
-        private readonly Container content;
-
-        protected override Container<Drawable> Content => content;
-
         public HeaderButton()
         {
-            CornerRadius = 3;
+            Height = 0;
-            Masking = true;
+            RelativeSizeAxes = Axes.Y;
+        }
 
-            InternalChildren = new Drawable[]
+        [BackgroundDependencyLoader]
+        private void load()
         {
-                new Box
+            BackgroundColour = OsuColour.FromHex(@"094c5f");
-                {
+            Triangles.ColourLight = OsuColour.FromHex(@"0f7c9b");
-                    RelativeSizeAxes = Axes.Both,
+            Triangles.ColourDark = OsuColour.FromHex(@"094c5f");
-                    Colour = OsuColour.FromHex(@"094c5f"),
+            Triangles.TriangleScale = 1.5f;
-                },
-                new Triangles
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    ColourLight = OsuColour.FromHex(@"0f7c9b"),
-                    ColourDark = OsuColour.FromHex(@"094c5f"),
-                    TriangleScale = 1.5f,
-                },
-                content = new Container
-                {
-                    RelativeSizeAxes = Axes.Both,
-                },
-            };
         }
     }
 }

osu.Game/Overlays/Direct/FilterControl.cs

@@ -105,6 +105,7 @@ namespace osu.Game.Overlays.Direct
 
     public enum DirectSortCriteria
     {
+        Relevance,
         Title,
         Artist,
         Creator,

osu.Game/Overlays/DirectOverlay.cs

@@ -43,6 +43,7 @@ namespace osu.Game.Overlays
         protected override SearchableListFilterControl<DirectSortCriteria, RankStatus> CreateFilterControl() => new FilterControl();
 
         private IEnumerable<BeatmapSetInfo> beatmapSets;
+
         public IEnumerable<BeatmapSetInfo> BeatmapSets
         {
             get { return beatmapSets; }
@@ -69,6 +70,7 @@ namespace osu.Game.Overlays
         }
 
         private ResultCounts resultAmounts;
+
         public ResultCounts ResultAmounts
         {
             get { return resultAmounts; }
@@ -115,7 +117,23 @@ namespace osu.Game.Overlays
                 },
             };
 
-            Filter.Search.Current.ValueChanged += text => { if (text != string.Empty) Header.Tabs.Current.Value = DirectTab.Search; };
+            Filter.Search.Current.ValueChanged += text =>
+            {
+                if (text != string.Empty)
+                {
+                    Header.Tabs.Current.Value = DirectTab.Search;
+
+                    if (Filter.Tabs.Current.Value == DirectSortCriteria.Ranked)
+                        Filter.Tabs.Current.Value = DirectSortCriteria.Relevance;
+                }
+                else
+                {
+                    Header.Tabs.Current.Value = DirectTab.NewestMaps;
+
+                    if (Filter.Tabs.Current.Value == DirectSortCriteria.Relevance)
+                        Filter.Tabs.Current.Value = DirectSortCriteria.Ranked;
+                }
+            };
             ((FilterControl)Filter).Ruleset.ValueChanged += ruleset => Scheduler.AddOnce(updateSearch);
             Filter.DisplayStyleControl.DisplayStyle.ValueChanged += recreatePanels;
             Filter.DisplayStyleControl.Dropdown.Current.ValueChanged += rankStatus => Scheduler.AddOnce(updateSearch);

osu.Game/Overlays/KeyBinding/GlobalKeyBindingsSection.cs

@@ -12,7 +12,7 @@ namespace osu.Game.Overlays.KeyBinding
         public override FontAwesome Icon => FontAwesome.fa_osu_hot;
         public override string Header => "Global";
 
-        public GlobalKeyBindingsSection(KeyBindingInputManager manager)
+        public GlobalKeyBindingsSection(KeyBindingContainer manager)
         {
             Add(new DefaultBindingsSubsection(manager));
         }
@@ -21,7 +21,7 @@ namespace osu.Game.Overlays.KeyBinding
         {
             protected override string Header => string.Empty;
 
-            public DefaultBindingsSubsection(KeyBindingInputManager manager)
+            public DefaultBindingsSubsection(KeyBindingContainer manager)
                 : base(null)
             {
                 Defaults = manager.DefaultKeyBindings;

osu.Game/Overlays/Music/PlaylistList.cs

@@ -35,7 +35,11 @@ namespace osu.Game.Overlays.Music
             set { base.Padding = value; }
         }
 
-        public IEnumerable<BeatmapSetInfo> BeatmapSets { set { items.Sets = value; } }
+        public IEnumerable<BeatmapSetInfo> BeatmapSets
+        {
+            get { return items.Sets; }
+            set { items.Sets = value; }
+        }
 
         public BeatmapSetInfo FirstVisibleSet => items.FirstVisibleSet;
         public BeatmapSetInfo NextSet => items.NextSet;
@@ -48,7 +52,7 @@ namespace osu.Game.Overlays.Music
         }
 
         public void AddBeatmapSet(BeatmapSetInfo beatmapSet) => items.AddBeatmapSet(beatmapSet);
-        public bool RemoveBeatmapSet(BeatmapSetInfo beatmapSet) => items.RemoveBeatmapSet(beatmapSet);
+        public void RemoveBeatmapSet(BeatmapSetInfo beatmapSet) => items.RemoveBeatmapSet(beatmapSet);
 
         public void Filter(string searchTerm) => items.SearchTerm = searchTerm;
 
@@ -81,6 +85,7 @@ namespace osu.Game.Overlays.Music
 
             public IEnumerable<BeatmapSetInfo> Sets
             {
+                get { return items.Select(x => x.BeatmapSetInfo).ToList(); }
                 set
                 {
                     items.Clear();
@@ -103,12 +108,11 @@ namespace osu.Game.Overlays.Music
                 });
             }
 
-            public bool RemoveBeatmapSet(BeatmapSetInfo beatmapSet)
+            public void RemoveBeatmapSet(BeatmapSetInfo beatmapSet)
             {
                 var itemToRemove = items.FirstOrDefault(i => i.BeatmapSetInfo.ID == beatmapSet.ID);
-                if (itemToRemove == null)
+                if (itemToRemove != null)
-                    return false;
+                    items.Remove(itemToRemove);
-                return items.Remove(itemToRemove);
             }
 
             public BeatmapSetInfo SelectedSet
@@ -230,6 +234,7 @@ namespace osu.Game.Overlays.Music
             private class ItemSearchContainer : FillFlowContainer<PlaylistItem>, IHasFilterableChildren
             {
                 public IEnumerable<string> FilterTerms => new string[] { };
+
                 public bool MatchingFilter
                 {
                     set

osu.Game/Overlays/Music/PlaylistOverlay.cs

@@ -13,6 +13,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using OpenTK;
 using OpenTK.Graphics;
+using System.Threading;
 
 namespace osu.Game.Overlays.Music
 {
@@ -29,7 +30,7 @@ namespace osu.Game.Overlays.Music
 
         private readonly Bindable<WorkingBeatmap> beatmapBacking = new Bindable<WorkingBeatmap>();
 
-        public IEnumerable<BeatmapSetInfo> BeatmapSets;
+        public IEnumerable<BeatmapSetInfo> BeatmapSets => list.BeatmapSets;
 
         [BackgroundDependencyLoader]
         private void load(OsuGameBase game, BeatmapManager beatmaps, OsuColour colours)
@@ -74,11 +75,10 @@ namespace osu.Game.Overlays.Music
                 },
             };
 
-            beatmaps.BeatmapSetAdded += s => Schedule(() => list.AddBeatmapSet(s));
+            beatmaps.BeatmapSetAdded += list.AddBeatmapSet;
-            beatmaps.BeatmapSetRemoved += s => Schedule(() => list.RemoveBeatmapSet(s));
+            beatmaps.BeatmapSetRemoved += list.RemoveBeatmapSet;
-
-            list.BeatmapSets = BeatmapSets = beatmaps.GetAllUsableBeatmapSets();
 
+            list.BeatmapSets = beatmaps.GetAllUsableBeatmapSets();
 
             beatmapBacking.BindTo(game.Beatmap);
 
@@ -121,7 +121,7 @@ namespace osu.Game.Overlays.Music
                 return;
             }
 
-            playSpecified(set.Beatmaps[0]);
+            playSpecified(set.Beatmaps.First());
         }
 
         public void PlayPrevious()
@@ -130,7 +130,7 @@ namespace osu.Game.Overlays.Music
 
             if (playable != null)
             {
-                playSpecified(playable.Beatmaps[0]);
+                playSpecified(playable.Beatmaps.First());
                 list.SelectedSet = playable;
             }
         }
@@ -141,7 +141,7 @@ namespace osu.Game.Overlays.Music
 
             if (playable != null)
             {
-                playSpecified(playable.Beatmaps[0]);
+                playSpecified(playable.Beatmaps.First());
                 list.SelectedSet = playable;
             }
         }
@@ -149,7 +149,15 @@ namespace osu.Game.Overlays.Music
         private void playSpecified(BeatmapInfo info)
         {
             beatmapBacking.Value = beatmaps.GetWorkingBeatmap(info, beatmapBacking);
-            beatmapBacking.Value.Track.Start();
+
+            var track = beatmapBacking.Value.Track;
+
+            track.Restart();
+
+            // this is temporary until we have blocking (async.Wait()) audio component methods.
+            // then we can call RestartAsync().Wait() or the blocking version above.
+            while (!track.IsRunning)
+                Thread.Sleep(1);
         }
     }
 

osu.Game/Overlays/MusicController.cs

@@ -251,7 +251,7 @@ namespace osu.Game.Overlays
 
                 playButton.Icon = track.IsRunning ? FontAwesome.fa_pause_circle_o : FontAwesome.fa_play_circle_o;
 
-                if (track.HasCompleted && !track.Looping && !beatmapBacking.Disabled)
+                if (track.HasCompleted && !beatmapBacking.Disabled && playlist.BeatmapSets.Any())
                     next();
             }
             else

osu.Game/Overlays/Profile/ProfileHeader.cs

@@ -382,7 +382,7 @@ namespace osu.Game.Overlays.Profile
             }
 
             tryAddInfoRightLine(FontAwesome.fa_map_marker, user.Location);
-            tryAddInfoRightLine(FontAwesome.fa_heart_o, user.Intrerests);
+            tryAddInfoRightLine(FontAwesome.fa_heart_o, user.Interests);
             tryAddInfoRightLine(FontAwesome.fa_suitcase, user.Occupation);
             infoTextRight.NewParagraph();
             if (!string.IsNullOrEmpty(user.Twitter))

osu.Game/Overlays/Settings/Sections/Input/MouseSettings.cs

@@ -97,6 +97,11 @@ namespace osu.Game.Overlays.Settings.Sections.Input
                     doubleValue.ValueChanged += newValue => base.Bindable.Value = newValue;
                 }
             }
+
+            public SensitivitySetting()
+            {
+                KeyboardStep = 0.01f;
+            }
         }
 
         private class SensitivitySlider : OsuSliderBar<double>
@@ -105,8 +110,6 @@ namespace osu.Game.Overlays.Settings.Sections.Input
 
             public SensitivitySlider()
             {
-                KeyboardStep = 0.01f;
-
                 Current.ValueChanged += newValue =>
                 {
                     if (!isDragging && Sensitivity != null)

osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs

@@ -177,8 +177,8 @@ namespace osu.Game.Rulesets.Objects.Legacy
 
             string[] split = str.Split(':');
 
-            var bank = (OsuLegacyDecoder.LegacySampleBank)Convert.ToInt32(split[0]);
+            var bank = (LegacyDecoder.LegacySampleBank)Convert.ToInt32(split[0]);
-            var addbank = (OsuLegacyDecoder.LegacySampleBank)Convert.ToInt32(split[1]);
+            var addbank = (LegacyDecoder.LegacySampleBank)Convert.ToInt32(split[1]);
 
             // Let's not implement this for now, because this doesn't fit nicely into the bank structure
             //string sampleFile = split2.Length > 4 ? split2[4] : string.Empty;

osu.Game/Rulesets/UI/RulesetInputManager.cs

@@ -5,6 +5,8 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Timing;
@@ -16,11 +18,24 @@ using OpenTK.Input;
 
 namespace osu.Game.Rulesets.UI
 {
-    public abstract class RulesetInputManager<T> : DatabasedKeyBindingInputManager<T>, ICanAttachKeyCounter, IHasReplayHandler
+    public abstract class RulesetInputManager<T> : PassThroughInputManager, ICanAttachKeyCounter, IHasReplayHandler
         where T : struct
     {
-        protected RulesetInputManager(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique) : base(ruleset, variant, unique)
+        public class RulesetKeyBindingContainer : DatabasedKeyBindingInputManager<T>
         {
+            public RulesetKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+                : base(ruleset, variant, unique)
+            {
+            }
+        }
+
+        protected readonly KeyBindingContainer<T> KeyBindingContainer;
+
+        protected override Container<Drawable> Content => KeyBindingContainer;
+
+        protected RulesetInputManager(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+        {
+            InternalChild = KeyBindingContainer = new RulesetKeyBindingContainer(ruleset, variant, unique);
         }
 
         #region Action mapping (for replays)
@@ -41,10 +56,10 @@ namespace osu.Game.Rulesets.UI
             List<T> newActions = replayState.PressedActions;
 
             foreach (var released in lastPressedActions.Except(newActions))
-                PropagateReleased(KeyBindingInputQueue, released);
+                KeyBindingContainer.TriggerReleased(released);
 
             foreach (var pressed in newActions.Except(lastPressedActions))
-                PropagatePressed(KeyBindingInputQueue, pressed);
+                KeyBindingContainer.TriggerPressed(pressed);
 
             lastPressedActions = newActions;
         }
@@ -203,7 +218,7 @@ namespace osu.Game.Rulesets.UI
             Add(receptor);
             keyCounter.SetReceptor(receptor);
 
-            keyCounter.AddRange(DefaultKeyBindings.Select(b => b.GetAction<T>()).Distinct().Select(b => new KeyCounterAction<T>(b)));
+            keyCounter.AddRange(KeyBindingContainer.DefaultKeyBindings.Select(b => b.GetAction<T>()).Distinct().Select(b => new KeyCounterAction<T>(b)));
         }
 
         public class ActionReceptor : KeyCounterCollection.Receptor, IKeyBindingHandler<T>

osu.Game/Screens/Loader.cs

@@ -1,8 +1,12 @@
 // Copyright (c) 2007-2017 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.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shaders;
 using osu.Game.Screens.Menu;
 using OpenTK;
 using osu.Framework.Screens;
@@ -33,14 +37,28 @@ namespace osu.Game.Screens
             logo.FadeInFromZero(5000, Easing.OutQuint);
         }
 
+        private OsuScreen loadScreen;
+        private ShaderPrecompiler precompiler;
+
         protected override void OnEntering(Screen last)
         {
             base.OnEntering(last);
 
-            if (showDisclaimer)
+            LoadComponentAsync(precompiler = new ShaderPrecompiler(loadIfReady), Add);
-                LoadComponentAsync(new Disclaimer(), d => Push(d));
+            LoadComponentAsync(loadScreen = showDisclaimer ? (OsuScreen)new Disclaimer() : new Intro(), s => loadIfReady());
-            else
+        }
-                LoadComponentAsync(new Intro(), d => Push(d));
+
+        private void loadIfReady()
+        {
+            if (ChildScreen == loadScreen) return;
+
+            if (loadScreen.LoadState != LoadState.Ready)
+                return;
+
+            if (!precompiler.FinishedCompiling)
+                return;
+
+            Push(loadScreen);
         }
 
         protected override void LogoSuspending(OsuLogo logo)
@@ -54,5 +72,49 @@ namespace osu.Game.Screens
         {
             showDisclaimer = game.IsDeployedBuild;
         }
+
+        /// <summary>
+        /// Compiles a set of shaders before continuing. Attempts to draw some frames between compilation by limiting to one compile per draw frame.
+        /// </summary>
+        public class ShaderPrecompiler : Drawable
+        {
+            private readonly Action onLoaded;
+            private readonly List<Shader> loadTargets = new List<Shader>();
+
+            public bool FinishedCompiling { get; private set; }
+
+            public ShaderPrecompiler(Action onLoaded)
+            {
+                this.onLoaded = onLoaded;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(ShaderManager manager)
+            {
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED));
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.BLUR));
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE));
+
+                loadTargets.Add(manager.Load(@"CursorTrail", FragmentShaderDescriptor.TEXTURE));
+
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE_ROUNDED));
+                loadTargets.Add(manager.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE));
+            }
+
+            private Shader currentLoadTarget;
+
+            protected override void Update()
+            {
+                base.Update();
+
+                // if our target is null we are done.
+                if (loadTargets.All(s => s.Loaded))
+                {
+                    FinishedCompiling = true;
+                    Expire();
+                    onLoaded?.Invoke();
+                }
+            }
+        }
     }
 }

osu.Game/Screens/Play/Player.cs

@@ -245,7 +245,7 @@ namespace osu.Game.Screens.Play
 
         private void initializeStoryboard(bool asyncLoad)
         {
-            var beatmap = Beatmap.Value.Beatmap;
+            var beatmap = Beatmap.Value;
 
             storyboard = beatmap.Storyboard.CreateDrawable(Beatmap.Value);
             storyboard.Masking = true;
@@ -388,7 +388,7 @@ namespace osu.Game.Screens.Play
                 initializeStoryboard(true);
 
             var beatmap = Beatmap.Value;
-            var storyboardVisible = showStoryboard && beatmap.Beatmap.Storyboard.HasDrawable;
+            var storyboardVisible = showStoryboard && beatmap.Storyboard.HasDrawable;
 
             storyboardContainer.FadeColour(new Color4(opacity, opacity, opacity, 1), 800);
             storyboardContainer.FadeTo(storyboardVisible && opacity > 0 ? 1 : 0);

osu.Game/Storyboards/Storyboard.cs

@@ -5,10 +5,11 @@ using osu.Game.Beatmaps;
 using osu.Game.Storyboards.Drawables;
 using System.Collections.Generic;
 using System.Linq;
+using System;
 
 namespace osu.Game.Storyboards
 {
-    public class Storyboard
+    public class Storyboard : IDisposable
     {
         private readonly Dictionary<string, StoryboardLayer> layers = new Dictionary<string, StoryboardLayer>();
         public IEnumerable<StoryboardLayer> Layers => layers.Values;
@@ -59,5 +60,29 @@ namespace osu.Game.Storyboards
             }
             return drawable;
         }
+
+        #region Disposal
+
+        ~Storyboard()
+        {
+            Dispose(false);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        private bool isDisposed;
+
+        protected virtual void Dispose(bool isDisposing)
+        {
+            if (isDisposed)
+                return;
+            isDisposed = true;
+        }
+
+        #endregion
     }
 }

osu.Game/Tests/Visual/TestCasePlayer.cs

@@ -8,7 +8,6 @@ using System.Text;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.Formats;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Screens.Play;
@@ -63,7 +62,7 @@ namespace osu.Game.Tests.Visual
 
             using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(test_beatmap_data)))
             using (var reader = new StreamReader(stream))
-                beatmap = BeatmapDecoder.GetDecoder(reader).Decode(reader);
+                beatmap = Game.Beatmaps.Formats.Decoder.GetDecoder(reader).DecodeBeatmap(reader);
 
             return beatmap;
         }

osu.Game/Users/User.cs

@@ -75,7 +75,7 @@ namespace osu.Game.Users
         public bool Active;
 
         [JsonProperty(@"interests")]
-        public string Intrerests;
+        public string Interests;
 
         [JsonProperty(@"occupation")]
         public string Occupation;

osu.Game/osu.Game.csproj

@@ -266,6 +266,8 @@
     <Compile Include="Beatmaps\Drawables\BeatmapPanel.cs" />
     <Compile Include="Beatmaps\Drawables\BeatmapSetCover.cs" />
     <Compile Include="Beatmaps\Drawables\BeatmapSetHeader.cs" />
+    <Compile Include="Beatmaps\Formats\LegacyDecoder.cs" />
+    <Compile Include="Beatmaps\Formats\LegacyStoryboardDecoder.cs" />
     <Compile Include="Database\DatabaseContextFactory.cs" />
     <Compile Include="Database\IHasPrimaryKey.cs" />
     <Compile Include="Graphics\UserInterface\HoverClickSounds.cs" />
@@ -307,8 +309,8 @@
     <Compile Include="Beatmaps\Drawables\DifficultyIcon.cs" />
     <Compile Include="Beatmaps\Drawables\Panel.cs" />
     <Compile Include="Beatmaps\DummyWorkingBeatmap.cs" />
-    <Compile Include="Beatmaps\Formats\BeatmapDecoder.cs" />
+    <Compile Include="Beatmaps\Formats\Decoder.cs" />
-    <Compile Include="Beatmaps\Formats\OsuLegacyDecoder.cs" />
+    <Compile Include="Beatmaps\Formats\LegacyBeatmapDecoder.cs" />
     <Compile Include="Beatmaps\IO\ArchiveReader.cs" />
     <Compile Include="Beatmaps\IO\LegacyFilesystemReader.cs" />
     <Compile Include="Online\API\Requests\GetUserScoresRequest.cs" />