Merge branch 'master' into fix-catch-droplets

osu.Game.Tests/Visual/TestCaseEditorCompose.cs

@@ -1,48 +1,36 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System;
 using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Game.Beatmaps;
+using osu.Framework.Timing;
+using osu.Game.Rulesets.Osu;
 using osu.Game.Screens.Edit.Screens.Compose;
+using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Tests.Visual
 {
     [TestFixture]
     public class TestCaseEditorCompose : OsuTestCase
     {
-        private readonly Random random;
+        private DependencyContainer dependencies;
-        private readonly Compose compose;
 
-        public TestCaseEditorCompose()
+        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
-        {
+            => dependencies = new DependencyContainer(parent);
-            random = new Random(1337);
-
-            Add(compose = new Compose());
-            AddStep("Next beatmap", nextBeatmap);
-        }
-
-        private OsuGameBase osuGame;
-        private BeatmapManager beatmaps;
 
         [BackgroundDependencyLoader]
-        private void load(OsuGameBase osuGame, BeatmapManager beatmaps)
+        private void load(OsuGameBase osuGame)
         {
-            this.osuGame = osuGame;
+            osuGame.Beatmap.Value = new TestWorkingBeatmap(new OsuRuleset().RulesetInfo);
-            this.beatmaps = beatmaps;
 
+            var clock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+            dependencies.CacheAs<IAdjustableClock>(clock);
+            dependencies.CacheAs<IFrameBasedClock>(clock);
+
+            var compose = new Compose();
             compose.Beatmap.BindTo(osuGame.Beatmap);
-        }
 
-        private void nextBeatmap()
+            Child = compose;
-        {
-            var sets = beatmaps.GetAllUsableBeatmapSets();
-            if (sets.Count == 0)
-                return;
-
-            var b = sets[random.Next(0, sets.Count)].Beatmaps[0];
-            osuGame.Beatmap.Value = beatmaps.GetWorkingBeatmap(b);
         }
     }
 }

osu.Game.Tests/Visual/TestCaseEditorSeekSnapping.cs

@@ -10,6 +10,7 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets;
@@ -30,9 +31,20 @@ namespace osu.Game.Tests.Visual
         private Track track;
         private HitObjectComposer composer;
 
+        private DecoupleableInterpolatingFramedClock clock;
+
+        private DependencyContainer dependencies;
+
+        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+            => dependencies = new DependencyContainer(parent);
+
         [BackgroundDependencyLoader]
         private void load(OsuGameBase osuGame)
         {
+            clock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+            dependencies.CacheAs<IAdjustableClock>(clock);
+            dependencies.CacheAs<IFrameBasedClock>(clock);
+
             var testBeatmap = new Beatmap
             {
                 ControlPointInfo = new ControlPointInfo
@@ -63,7 +75,7 @@ namespace osu.Game.Tests.Visual
                 Content = new[]
                 {
                     new Drawable[] { composer = new TestHitObjectComposer(new OsuRuleset()) },
-                    new Drawable[] { new TimingPointVisualiser(testBeatmap, track) },
+                    new Drawable[] { new TimingPointVisualiser(testBeatmap, track) { Clock = clock } },
                 },
                 RowDimensions = new[]
                 {
@@ -92,17 +104,17 @@ namespace osu.Game.Tests.Visual
 
             // Forwards
             AddStep("Seek(0)", () => composer.SeekTo(0));
-            AddAssert("Time = 0", () => track.CurrentTime == 0);
+            AddAssert("Time = 0", () => clock.CurrentTime == 0);
             AddStep("Seek(33)", () => composer.SeekTo(33));
-            AddAssert("Time = 33", () => track.CurrentTime == 33);
+            AddAssert("Time = 33", () => clock.CurrentTime == 33);
             AddStep("Seek(89)", () => composer.SeekTo(89));
-            AddAssert("Time = 89", () => track.CurrentTime == 89);
+            AddAssert("Time = 89", () => clock.CurrentTime == 89);
 
             // Backwards
             AddStep("Seek(25)", () => composer.SeekTo(25));
-            AddAssert("Time = 25", () => track.CurrentTime == 25);
+            AddAssert("Time = 25", () => clock.CurrentTime == 25);
             AddStep("Seek(0)", () => composer.SeekTo(0));
-            AddAssert("Time = 0", () => track.CurrentTime == 0);
+            AddAssert("Time = 0", () => clock.CurrentTime == 0);
         }
 
         /// <summary>
@@ -114,19 +126,19 @@ namespace osu.Game.Tests.Visual
             reset();
 
             AddStep("Seek(0), Snap", () => composer.SeekTo(0, true));
-            AddAssert("Time = 0", () => track.CurrentTime == 0);
+            AddAssert("Time = 0", () => clock.CurrentTime == 0);
             AddStep("Seek(50), Snap", () => composer.SeekTo(50, true));
-            AddAssert("Time = 50", () => track.CurrentTime == 50);
+            AddAssert("Time = 50", () => clock.CurrentTime == 50);
             AddStep("Seek(100), Snap", () => composer.SeekTo(100, true));
-            AddAssert("Time = 100", () => track.CurrentTime == 100);
+            AddAssert("Time = 100", () => clock.CurrentTime == 100);
             AddStep("Seek(175), Snap", () => composer.SeekTo(175, true));
-            AddAssert("Time = 175", () => track.CurrentTime == 175);
+            AddAssert("Time = 175", () => clock.CurrentTime == 175);
             AddStep("Seek(350), Snap", () => composer.SeekTo(350, true));
-            AddAssert("Time = 350", () => track.CurrentTime == 350);
+            AddAssert("Time = 350", () => clock.CurrentTime == 350);
             AddStep("Seek(400), Snap", () => composer.SeekTo(400, true));
-            AddAssert("Time = 400", () => track.CurrentTime == 400);
+            AddAssert("Time = 400", () => clock.CurrentTime == 400);
             AddStep("Seek(450), Snap", () => composer.SeekTo(450, true));
-            AddAssert("Time = 450", () => track.CurrentTime == 450);
+            AddAssert("Time = 450", () => clock.CurrentTime == 450);
         }
 
         /// <summary>
@@ -139,17 +151,17 @@ namespace osu.Game.Tests.Visual
             reset();
 
             AddStep("Seek(24), Snap", () => composer.SeekTo(24, true));
-            AddAssert("Time = 0", () => track.CurrentTime == 0);
+            AddAssert("Time = 0", () => clock.CurrentTime == 0);
             AddStep("Seek(26), Snap", () => composer.SeekTo(26, true));
-            AddAssert("Time = 50", () => track.CurrentTime == 50);
+            AddAssert("Time = 50", () => clock.CurrentTime == 50);
             AddStep("Seek(150), Snap", () => composer.SeekTo(150, true));
-            AddAssert("Time = 100", () => track.CurrentTime == 100);
+            AddAssert("Time = 100", () => clock.CurrentTime == 100);
             AddStep("Seek(170), Snap", () => composer.SeekTo(170, true));
-            AddAssert("Time = 175", () => track.CurrentTime == 175);
+            AddAssert("Time = 175", () => clock.CurrentTime == 175);
             AddStep("Seek(274), Snap", () => composer.SeekTo(274, true));
-            AddAssert("Time = 175", () => track.CurrentTime == 175);
+            AddAssert("Time = 175", () => clock.CurrentTime == 175);
             AddStep("Seek(276), Snap", () => composer.SeekTo(276, true));
-            AddAssert("Time = 350", () => track.CurrentTime == 350);
+            AddAssert("Time = 350", () => clock.CurrentTime == 350);
         }
 
         /// <summary>
@@ -160,15 +172,15 @@ namespace osu.Game.Tests.Visual
             reset();
 
             AddStep("SeekForward", () => composer.SeekForward());
-            AddAssert("Time = 50", () => track.CurrentTime == 50);
+            AddAssert("Time = 50", () => clock.CurrentTime == 50);
             AddStep("SeekForward", () => composer.SeekForward());
-            AddAssert("Time = 100", () => track.CurrentTime == 100);
+            AddAssert("Time = 100", () => clock.CurrentTime == 100);
             AddStep("SeekForward", () => composer.SeekForward());
-            AddAssert("Time = 200", () => track.CurrentTime == 200);
+            AddAssert("Time = 200", () => clock.CurrentTime == 200);
             AddStep("SeekForward", () => composer.SeekForward());
-            AddAssert("Time = 400", () => track.CurrentTime == 400);
+            AddAssert("Time = 400", () => clock.CurrentTime == 400);
             AddStep("SeekForward", () => composer.SeekForward());
-            AddAssert("Time = 450", () => track.CurrentTime == 450);
+            AddAssert("Time = 450", () => clock.CurrentTime == 450);
         }
 
         /// <summary>
@@ -179,17 +191,17 @@ namespace osu.Game.Tests.Visual
             reset();
 
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 50", () => track.CurrentTime == 50);
+            AddAssert("Time = 50", () => clock.CurrentTime == 50);
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 100", () => track.CurrentTime == 100);
+            AddAssert("Time = 100", () => clock.CurrentTime == 100);
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 175", () => track.CurrentTime == 175);
+            AddAssert("Time = 175", () => clock.CurrentTime == 175);
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 350", () => track.CurrentTime == 350);
+            AddAssert("Time = 350", () => clock.CurrentTime == 350);
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 400", () => track.CurrentTime == 400);
+            AddAssert("Time = 400", () => clock.CurrentTime == 400);
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 450", () => track.CurrentTime == 450);
+            AddAssert("Time = 450", () => clock.CurrentTime == 450);
         }
 
         /// <summary>
@@ -202,28 +214,28 @@ namespace osu.Game.Tests.Visual
 
             AddStep("Seek(49)", () => composer.SeekTo(49));
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 50", () => track.CurrentTime == 50);
+            AddAssert("Time = 50", () => clock.CurrentTime == 50);
             AddStep("Seek(49.999)", () => composer.SeekTo(49.999));
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 50", () => track.CurrentTime == 50);
+            AddAssert("Time = 50", () => clock.CurrentTime == 50);
             AddStep("Seek(99)", () => composer.SeekTo(99));
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 100", () => track.CurrentTime == 100);
+            AddAssert("Time = 100", () => clock.CurrentTime == 100);
             AddStep("Seek(99.999)", () => composer.SeekTo(99.999));
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 100", () => track.CurrentTime == 100);
+            AddAssert("Time = 100", () => clock.CurrentTime == 100);
             AddStep("Seek(174)", () => composer.SeekTo(174));
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 175", () => track.CurrentTime == 175);
+            AddAssert("Time = 175", () => clock.CurrentTime == 175);
             AddStep("Seek(349)", () => composer.SeekTo(349));
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 350", () => track.CurrentTime == 350);
+            AddAssert("Time = 350", () => clock.CurrentTime == 350);
             AddStep("Seek(399)", () => composer.SeekTo(399));
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 400", () => track.CurrentTime == 400);
+            AddAssert("Time = 400", () => clock.CurrentTime == 400);
             AddStep("Seek(449)", () => composer.SeekTo(449));
             AddStep("SeekForward, Snap", () => composer.SeekForward(true));
-            AddAssert("Time = 450", () => track.CurrentTime == 450);
+            AddAssert("Time = 450", () => clock.CurrentTime == 450);
         }
 
         /// <summary>
@@ -235,17 +247,17 @@ namespace osu.Game.Tests.Visual
 
             AddStep("Seek(450)", () => composer.SeekTo(450));
             AddStep("SeekBackward", () => composer.SeekBackward());
-            AddAssert("Time = 425", () => track.CurrentTime == 425);
+            AddAssert("Time = 425", () => clock.CurrentTime == 425);
             AddStep("SeekBackward", () => composer.SeekBackward());
-            AddAssert("Time = 375", () => track.CurrentTime == 375);
+            AddAssert("Time = 375", () => clock.CurrentTime == 375);
             AddStep("SeekBackward", () => composer.SeekBackward());
-            AddAssert("Time = 325", () => track.CurrentTime == 325);
+            AddAssert("Time = 325", () => clock.CurrentTime == 325);
             AddStep("SeekBackward", () => composer.SeekBackward());
-            AddAssert("Time = 125", () => track.CurrentTime == 125);
+            AddAssert("Time = 125", () => clock.CurrentTime == 125);
             AddStep("SeekBackward", () => composer.SeekBackward());
-            AddAssert("Time = 25", () => track.CurrentTime == 25);
+            AddAssert("Time = 25", () => clock.CurrentTime == 25);
             AddStep("SeekBackward", () => composer.SeekBackward());
-            AddAssert("Time = 0", () => track.CurrentTime == 0);
+            AddAssert("Time = 0", () => clock.CurrentTime == 0);
         }
 
         /// <summary>
@@ -257,17 +269,17 @@ namespace osu.Game.Tests.Visual
 
             AddStep("Seek(450)", () => composer.SeekTo(450));
             AddStep("SeekBackward, Snap", () => composer.SeekBackward(true));
-            AddAssert("Time = 400", () => track.CurrentTime == 400);
+            AddAssert("Time = 400", () => clock.CurrentTime == 400);
             AddStep("SeekBackward, Snap", () => composer.SeekBackward(true));
-            AddAssert("Time = 350", () => track.CurrentTime == 350);
+            AddAssert("Time = 350", () => clock.CurrentTime == 350);
             AddStep("SeekBackward, Snap", () => composer.SeekBackward(true));
-            AddAssert("Time = 175", () => track.CurrentTime == 175);
+            AddAssert("Time = 175", () => clock.CurrentTime == 175);
             AddStep("SeekBackward, Snap", () => composer.SeekBackward(true));
-            AddAssert("Time = 100", () => track.CurrentTime == 100);
+            AddAssert("Time = 100", () => clock.CurrentTime == 100);
             AddStep("SeekBackward, Snap", () => composer.SeekBackward(true));
-            AddAssert("Time = 50", () => track.CurrentTime == 50);
+            AddAssert("Time = 50", () => clock.CurrentTime == 50);
             AddStep("SeekBackward, Snap", () => composer.SeekBackward(true));
-            AddAssert("Time = 0", () => track.CurrentTime == 0);
+            AddAssert("Time = 0", () => clock.CurrentTime == 0);
         }
 
         /// <summary>
@@ -280,16 +292,16 @@ namespace osu.Game.Tests.Visual
 
             AddStep("Seek(451)", () => composer.SeekTo(451));
             AddStep("SeekBackward, Snap", () => composer.SeekBackward(true));
-            AddAssert("Time = 450", () => track.CurrentTime == 450);
+            AddAssert("Time = 450", () => clock.CurrentTime == 450);
             AddStep("Seek(450.999)", () => composer.SeekTo(450.999));
             AddStep("SeekBackward, Snap", () => composer.SeekBackward(true));
-            AddAssert("Time = 450", () => track.CurrentTime == 450);
+            AddAssert("Time = 450", () => clock.CurrentTime == 450);
             AddStep("Seek(401)", () => composer.SeekTo(401));
             AddStep("SeekBackward, Snap", () => composer.SeekBackward(true));
-            AddAssert("Time = 400", () => track.CurrentTime == 400);
+            AddAssert("Time = 400", () => clock.CurrentTime == 400);
             AddStep("Seek(401.999)", () => composer.SeekTo(401.999));
             AddStep("SeekBackward, Snap", () => composer.SeekBackward(true));
-            AddAssert("Time = 400", () => track.CurrentTime == 400);
+            AddAssert("Time = 400", () => clock.CurrentTime == 400);
         }
 
         /// <summary>
@@ -307,23 +319,23 @@ namespace osu.Game.Tests.Visual
             {
                 AddStep("SeekForward, Snap", () =>
                 {
-                    lastTime = track.CurrentTime;
+                    lastTime = clock.CurrentTime;
                     composer.SeekForward(true);
                 });
-                AddAssert("Time > lastTime", () => track.CurrentTime > lastTime);
+                AddAssert("Time > lastTime", () => clock.CurrentTime > lastTime);
             }
 
             for (int i = 0; i < 20; i++)
             {
                 AddStep("SeekBackward, Snap", () =>
                 {
-                    lastTime = track.CurrentTime;
+                    lastTime = clock.CurrentTime;
                     composer.SeekBackward(true);
                 });
-                AddAssert("Time < lastTime", () => track.CurrentTime < lastTime);
+                AddAssert("Time < lastTime", () => clock.CurrentTime < lastTime);
             }
 
-            AddAssert("Time = 0", () => track.CurrentTime == 0);
+            AddAssert("Time = 0", () => clock.CurrentTime == 0);
         }
 
         private void reset()
@@ -409,7 +421,7 @@ namespace osu.Game.Tests.Visual
             {
                 base.Update();
 
-                tracker.X = (float)(track.CurrentTime / track.Length);
+                tracker.X = (float)(Time.Current / track.Length);
             }
 
             private class TimingPointTimeline : CompositeDrawable

osu.Game.Tests/Visual/TestCaseEditorSelectionLayer.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Timing;
 using OpenTK;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
@@ -34,6 +35,11 @@ namespace osu.Game.Tests.Visual
             typeof(SliderCircleMask)
         };
 
+        private DependencyContainer dependencies;
+
+        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+            => dependencies = new DependencyContainer(parent);
+
         [BackgroundDependencyLoader]
         private void load(OsuGameBase osuGame)
         {
@@ -59,6 +65,10 @@ namespace osu.Game.Tests.Visual
                 },
             });
 
+            var clock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+            dependencies.CacheAs<IAdjustableClock>(clock);
+            dependencies.CacheAs<IFrameBasedClock>(clock);
+
             Child = new OsuHitObjectComposer(new OsuRuleset());
         }
     }

osu.Game.Tests/Visual/TestCaseEditorSummaryTimeline.cs

@@ -4,30 +4,38 @@
 using System;
 using System.Collections.Generic;
 using NUnit.Framework;
-using osu.Framework.Audio.Track;
+using osu.Framework.Allocation;
-using osu.Framework.Graphics.Textures;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
 using OpenTK;
 using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osu.Framework.Configuration;
+using osu.Framework.Timing;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Tests.Visual
 {
     [TestFixture]
     public class TestCaseEditorSummaryTimeline : OsuTestCase
     {
-        private const int length = 60000;
-        private readonly Random random;
-
         public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(SummaryTimeline) };
 
         private readonly Bindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
 
-        public TestCaseEditorSummaryTimeline()
+        private DependencyContainer dependencies;
+
+        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+            => dependencies = new DependencyContainer(parent);
+
+        [BackgroundDependencyLoader]
+        private void load()
         {
-            random = new Random(1337);
+            beatmap.Value = new TestWorkingBeatmap(new OsuRuleset().RulesetInfo);
+
+            var clock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+            dependencies.CacheAs<IAdjustableClock>(clock);
+            dependencies.CacheAs<IFrameBasedClock>(clock);
 
             SummaryTimeline summaryTimeline;
             Add(summaryTimeline = new SummaryTimeline
@@ -38,58 +46,6 @@ namespace osu.Game.Tests.Visual
             });
 
             summaryTimeline.Beatmap.BindTo(beatmap);
-
-            AddStep("New beatmap", newBeatmap);
-
-            newBeatmap();
-        }
-
-        private void newBeatmap()
-        {
-            var b = new Beatmap();
-
-            for (int i = 0; i < random.Next(1, 10); i++)
-                b.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { Time = random.Next(0, length) });
-
-            for (int i = 0; i < random.Next(1, 5); i++)
-                b.ControlPointInfo.DifficultyPoints.Add(new DifficultyControlPoint { Time = random.Next(0, length) });
-
-            for (int i = 0; i < random.Next(1, 5); i++)
-                b.ControlPointInfo.EffectPoints.Add(new EffectControlPoint { Time = random.Next(0, length) });
-
-            for (int i = 0; i < random.Next(1, 5); i++)
-                b.ControlPointInfo.SamplePoints.Add(new SampleControlPoint { Time = random.Next(0, length) });
-
-            b.BeatmapInfo.Bookmarks = new int[random.Next(10, 30)];
-            for (int i = 0; i < b.BeatmapInfo.Bookmarks.Length; i++)
-                b.BeatmapInfo.Bookmarks[i] = random.Next(0, length);
-
-            beatmap.Value = new TestWorkingBeatmap(b);
-        }
-
-        private class TestWorkingBeatmap : WorkingBeatmap
-        {
-            private readonly Beatmap beatmap;
-
-            public TestWorkingBeatmap(Beatmap beatmap)
-                : base(beatmap.BeatmapInfo)
-            {
-                this.beatmap = beatmap;
-            }
-
-            protected override Texture GetBackground() => null;
-
-            protected override Beatmap GetBeatmap() => beatmap;
-
-            protected override Track GetTrack() => new TestTrack();
-
-            private class TestTrack : TrackVirtual
-            {
-                public TestTrack()
-                {
-                    Length = length;
-                }
-            }
         }
     }
 }

osu.Game.Tests/Visual/TestCasePlaybackControl.cs

@@ -2,7 +2,9 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using NUnit.Framework;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Screens.Edit.Components;
 using osu.Game.Tests.Beatmaps;
@@ -13,17 +15,28 @@ namespace osu.Game.Tests.Visual
     [TestFixture]
     public class TestCasePlaybackControl : OsuTestCase
     {
-        public TestCasePlaybackControl()
+        private DependencyContainer dependencies;
+
+        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+            => dependencies = new DependencyContainer(parent);
+
+        [BackgroundDependencyLoader]
+        private void load()
         {
+            var clock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+            dependencies.CacheAs<IAdjustableClock>(clock);
+            dependencies.CacheAs<IFrameBasedClock>(clock);
+
             var playback = new PlaybackControl
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 Size = new Vector2(200,100)
             };
+
             playback.Beatmap.Value = new TestWorkingBeatmap(new Beatmap());
 
-            Add(playback);
+            Child = playback;
         }
     }
 }

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -32,31 +32,26 @@ namespace osu.Game.Rulesets.Edit
 
         private readonly Bindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
 
-        private IAdjustableClock sourceClock;
+        private IAdjustableClock adjustableClock;
-        private DecoupleableInterpolatingFramedClock adjustableClock;
 
         protected HitObjectComposer(Ruleset ruleset)
         {
             this.ruleset = ruleset;
+
             RelativeSizeAxes = Axes.Both;
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuGameBase osuGame)
+        private void load(OsuGameBase osuGame, IAdjustableClock adjustableClock, IFrameBasedClock framedClock)
         {
+            this.adjustableClock = adjustableClock;
+
             beatmap.BindTo(osuGame.Beatmap);
 
             try
             {
                 rulesetContainer = CreateRulesetContainer(ruleset, beatmap.Value);
-
+                rulesetContainer.Clock = framedClock;
-                // TODO: should probably be done at a RulesetContainer level to share logic with Player.
-                sourceClock = (IAdjustableClock)beatmap.Value.Track ?? new StopwatchClock();
-                adjustableClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
-                adjustableClock.ChangeSource(sourceClock);
-
-                rulesetContainer.Clock = adjustableClock;
-
             }
             catch (Exception e)
             {

osu.Game/Screens/Edit/Components/PlaybackControl.cs

@@ -9,6 +9,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;
+using osu.Framework.Timing;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
@@ -17,10 +18,15 @@ namespace osu.Game.Screens.Edit.Components
 {
     public class PlaybackControl : BottomBarContainer
     {
-        private readonly IconButton playButton;
+        private IconButton playButton;
 
-        public PlaybackControl()
+        private IAdjustableClock adjustableClock;
+
+        [BackgroundDependencyLoader]
+        private void load(IAdjustableClock adjustableClock)
         {
+            this.adjustableClock = adjustableClock;
+
             PlaybackTabControl tabs;
 
             Children = new Drawable[]
@@ -54,22 +60,22 @@ namespace osu.Game.Screens.Edit.Components
                 }
             };
 
-            tabs.Current.ValueChanged += newValue => Track.Tempo.Value = newValue;
+            tabs.Current.ValueChanged += newValue => Beatmap.Value.Track.Tempo.Value = newValue;
         }
 
         private void togglePause()
         {
-            if (Track.IsRunning)
+            if (adjustableClock.IsRunning)
-                Track.Stop();
+                adjustableClock.Stop();
             else
-                Track.Start();
+                adjustableClock.Start();
         }
 
         protected override void Update()
         {
             base.Update();
 
-            playButton.Icon = Track.IsRunning ? FontAwesome.fa_pause_circle_o : FontAwesome.fa_play_circle_o;
+            playButton.Icon = adjustableClock.IsRunning ? FontAwesome.fa_pause_circle_o : FontAwesome.fa_play_circle_o;
         }
 
         private class PlaybackTabControl : OsuTabControl<double>

osu.Game/Screens/Edit/Components/TimeInfoContainer.cs

@@ -4,17 +4,20 @@
 using osu.Framework.Graphics;
 using osu.Game.Graphics.Sprites;
 using System;
+using osu.Framework.Allocation;
+using osu.Framework.Timing;
 
 namespace osu.Game.Screens.Edit.Components
 {
     public class TimeInfoContainer : BottomBarContainer
     {
-        private const int count_duration = 150;
-
         private readonly OsuSpriteText trackTimer;
 
+        private IAdjustableClock adjustableClock;
+
         public TimeInfoContainer()
         {
+
             Children = new Drawable[]
             {
                 trackTimer = new OsuSpriteText
@@ -28,11 +31,17 @@ namespace osu.Game.Screens.Edit.Components
             };
         }
 
+        [BackgroundDependencyLoader]
+        private void load(IAdjustableClock adjustableClock)
+        {
+            this.adjustableClock = adjustableClock;
+        }
+
         protected override void Update()
         {
             base.Update();
 
-            trackTimer.Text = TimeSpan.FromMilliseconds(Track.CurrentTime).ToString(@"mm\:ss\:fff");
+            trackTimer.Text = TimeSpan.FromMilliseconds(adjustableClock.CurrentTime).ToString(@"mm\:ss\:fff");
         }
     }
 }

osu.Game/Screens/Edit/Components/Timelines/Summary/Parts/MarkerPart.cs

@@ -7,6 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input;
+using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 
@@ -19,8 +20,12 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
     {
         private readonly Drawable marker;
 
-        public MarkerPart()
+        private readonly IAdjustableClock adjustableClock;
+
+        public MarkerPart(IAdjustableClock adjustableClock)
         {
+            this.adjustableClock = adjustableClock;
+
             Add(marker = new MarkerVisualisation());
         }
 
@@ -53,12 +58,12 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary.Parts
             seekTo(markerPos / DrawWidth * Beatmap.Value.Track.Length);
         }
 
-        private void seekTo(double time) => Beatmap.Value?.Track.Seek(time);
+        private void seekTo(double time) => adjustableClock.Seek(time);
 
         protected override void Update()
         {
             base.Update();
-            marker.X = (float)(Beatmap.Value?.Track.CurrentTime ?? 0);
+            marker.X = (float)adjustableClock.CurrentTime;
         }
 
         protected override void LoadBeatmap(WorkingBeatmap beatmap)

osu.Game/Screens/Edit/Components/Timelines/Summary/SummaryTimeline.cs

@@ -6,6 +6,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.Timing;
 using osu.Game.Graphics;
 using osu.Game.Screens.Edit.Components.Timelines.Summary.Parts;
 
@@ -16,15 +17,14 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary
     /// </summary>
     public class SummaryTimeline : BottomBarContainer
     {
-        private readonly Drawable timelineBar;
+        [BackgroundDependencyLoader]
-
+        private void load(OsuColour colours, IAdjustableClock adjustableClock)
-        public SummaryTimeline()
         {
             TimelinePart markerPart, controlPointPart, bookmarkPart, breakPart;
 
-            Children = new[]
+            Children = new Drawable[]
             {
-                markerPart = new MarkerPart { RelativeSizeAxes = Axes.Both },
+                markerPart = new MarkerPart(adjustableClock) { RelativeSizeAxes = Axes.Both },
                 controlPointPart = new ControlPointPart
                 {
                     Anchor = Anchor.Centre,
@@ -39,9 +39,10 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary
                     RelativeSizeAxes = Axes.Both,
                     Height = 0.35f
                 },
-                timelineBar = new Container
+                new Container
                 {
                     RelativeSizeAxes = Axes.Both,
+                    Colour = colours.Gray5,
                     Children = new Drawable[]
                     {
                         new Circle
@@ -80,11 +81,5 @@ namespace osu.Game.Screens.Edit.Components.Timelines.Summary
             bookmarkPart.Beatmap.BindTo(Beatmap);
             breakPart.Beatmap.BindTo(Beatmap);
         }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            timelineBar.Colour = colours.Gray5;
-        }
     }
 }

osu.Game/Screens/Edit/Editor.cs

@@ -12,6 +12,7 @@ using osu.Game.Screens.Edit.Menus;
 using osu.Game.Screens.Edit.Components.Timelines.Summary;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Timing;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Edit.Screens;
 using osu.Game.Screens.Edit.Screens.Compose;
@@ -26,13 +27,27 @@ namespace osu.Game.Screens.Edit
 
         public override bool ShowOverlaysOnEnter => false;
 
-        private readonly Box bottomBackground;
+        private Box bottomBackground;
-        private readonly Container screenContainer;
+        private Container screenContainer;
 
         private EditorScreen currentScreen;
 
-        public Editor()
+        private DependencyContainer dependencies;
+
+        protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
+            => dependencies = new DependencyContainer(parent);
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
         {
+            // TODO: should probably be done at a RulesetContainer level to share logic with Player.
+            var sourceClock = (IAdjustableClock)Beatmap.Value.Track ?? new StopwatchClock();
+            var adjustableClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+            adjustableClock.ChangeSource(sourceClock);
+
+            dependencies.CacheAs<IAdjustableClock>(adjustableClock);
+            dependencies.CacheAs<IFrameBasedClock>(adjustableClock);
+
             EditorMenuBar menuBar;
             TimeInfoContainer timeInfo;
             SummaryTimeline timeline;
@@ -130,12 +145,9 @@ namespace osu.Game.Screens.Edit
             timeline.Beatmap.BindTo(Beatmap);
             playback.Beatmap.BindTo(Beatmap);
             menuBar.Mode.ValueChanged += onModeChanged;
-        }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
             bottomBackground.Colour = colours.Gray2;
+
         }
 
         private void exportBeatmap()

osu.Game/Screens/Edit/Screens/Compose/Compose.cs

@@ -1,13 +1,13 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Allocation;
 using OpenTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Logging;
-using osu.Game.Beatmaps;
 using osu.Game.Screens.Edit.Screens.Compose.Timeline;
 
 namespace osu.Game.Screens.Edit.Screens.Compose
@@ -17,9 +17,10 @@ namespace osu.Game.Screens.Edit.Screens.Compose
         private const float vertical_margins = 10;
         private const float horizontal_margins = 20;
 
-        private readonly Container composerContainer;
+        private Container composerContainer;
 
-        public Compose()
+        [BackgroundDependencyLoader]
+        private void load()
         {
             ScrollableTimeline timeline;
             Children = new Drawable[]
@@ -75,14 +76,8 @@ namespace osu.Game.Screens.Edit.Screens.Compose
             };
 
             timeline.Beatmap.BindTo(Beatmap);
-            Beatmap.ValueChanged += beatmapChanged;
-        }
 
-        private void beatmapChanged(WorkingBeatmap newBeatmap)
+            var ruleset = Beatmap.Value.BeatmapInfo.Ruleset?.CreateInstance();
-        {
-            composerContainer.Clear();
-
-            var ruleset = newBeatmap.BeatmapInfo.Ruleset?.CreateInstance();
             if (ruleset == null)
             {
                 Logger.Log("Beatmap doesn't have a ruleset assigned.");

osu.Game/Screens/Edit/Screens/Compose/Layers/HitObjectMaskLayer.cs

@@ -51,7 +51,11 @@ namespace osu.Game.Screens.Edit.Screens.Compose.Layers
 
         private SelectionBox currentSelectionBox;
 
-        public void AddSelectionOverlay() => AddInternal(currentSelectionBox = composer.CreateSelectionOverlay(overlayContainer));
+        public void AddSelectionOverlay()
+        {
+            if (overlayContainer.Count > 0)
+                AddInternal(currentSelectionBox = composer.CreateSelectionOverlay(overlayContainer));
+        }
 
         public void RemoveSelectionOverlay()
         {