Merge pull request #1638 from Aergwyn/fix-beatmap-carousel-lag

Fix lagging beatmap carousel because of storyboard-loading

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,7 +495,7 @@ 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
@@ -517,8 +518,8 @@ namespace osu.Game.Beatmaps
                     raw.CopyTo(ms);
                     ms.Position = 0;
 
-                    var decoder = BeatmapDecoder.GetDecoder(sr);
-                    Beatmap beatmap = decoder.Decode(sr);
+                    var decoder = Decoder.GetDecoder(sr);
+                    Beatmap beatmap = decoder.DecodeBeatmap(sr);
 
                     beatmap.BeatmapInfo.Path = name;
                     beatmap.BeatmapInfo.Hash = ms.ComputeSHA2Hash();
@@ -568,23 +569,11 @@ namespace osu.Game.Beatmaps
             {
                 try
                 {
-                    Beatmap beatmap;
-
-                    BeatmapDecoder decoder;
                     using (var stream = new StreamReader(store.GetStream(getPathForFile(BeatmapInfo.Path))))
                     {
-                        decoder = BeatmapDecoder.GetDecoder(stream);
-                        beatmap = decoder.Decode(stream);
+                        Decoder decoder = Decoder.GetDecoder(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 +612,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,12 +35,14 @@ 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.IsResultAvailable;
         public Beatmap Beatmap => beatmap.Value.Result;
@@ -84,6 +87,13 @@ namespace osu.Game.Beatmaps
 
         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.IsResultAvailable && Track != null && BeatmapInfo.AudioEquals(other.BeatmapInfo))
@@ -97,6 +107,7 @@ namespace osu.Game.Beatmaps
         {
             if (BackgroundLoaded) Background?.Dispose();
             if (WaveformLoaded) Waveform?.Dispose();
+            if (StoryboardLoaded) Storyboard?.Dispose();
         }
 
         /// <summary>

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 addbank = (OsuLegacyDecoder.LegacySampleBank)Convert.ToInt32(split[1]);
+            var bank = (LegacyDecoder.LegacySampleBank)Convert.ToInt32(split[0]);
+            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/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/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\OsuLegacyDecoder.cs" />
+    <Compile Include="Beatmaps\Formats\Decoder.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" />