Merge pull request #1599 from naoey/leaderboard-scopes

Make leaderboard tabs and active ruleset filter scores

.vscode/tasks.json

@@ -2,63 +2,70 @@
     // See https://go.microsoft.com/fwlink/?LinkId=733558
     // for the documentation about the tasks.json format
     "version": "2.0.0",
-    "command": "msbuild",
-    "type": "shell",
-    "suppressTaskName": true,
-    "args": [
-        "/property:GenerateFullPaths=true",
-        "/property:DebugType=portable",
-        "/verbosity:minimal",
-        "/m" //parallel compiling support.
-    ],
     "tasks": [{
-            "taskName": "Build (Debug)",
+            "label": "Build (Debug)",
+            "type": "shell",
+            "command": "msbuild",
+            "args": [
+                "/p:GenerateFullPaths=true",
+                "/p:DebugType=portable",
+                "/m",
+                "/v:m"
+            ],
             "group": {
                 "kind": "build",
                 "isDefault": true
             },
-            "problemMatcher": [
-                "$msCompile"
-            ]
+            "problemMatcher": "$msCompile"
         },
         {
-            "taskName": "Build (Release)",
+            "label": "Build (Release)",
+            "type": "shell",
+            "command": "msbuild",
+            "args": [
+                "/p:Configuration=Release",
+                "/p:DebugType=portable",
+                "/p:GenerateFullPaths=true",
+                "/m",
+                "/v:m"
+            ],
             "group": "build",
-            "args": [
-                "/property:Configuration=Release"
-            ],
-            "problemMatcher": [
-                "$msCompile"
-            ]
+            "problemMatcher": "$msCompile"
         },
         {
-            "taskName": "Clean (Debug)",
+            "label": "Clean (Debug)",
+            "type": "shell",
+            "command": "msbuild",
             "args": [
-                "/target:Clean"
+                "/p:DebugType=portable",
+                "/p:GenerateFullPaths=true",
+                "/m",
+                "/t:Clean",
+                "/v:m"
             ],
-            "problemMatcher": [
-                "$msCompile"
-            ]
+            "problemMatcher": "$msCompile"
         },
         {
-            "taskName": "Clean (Release)",
+            "label": "Clean (Release)",
+            "type": "shell",
+            "command": "msbuild",
             "args": [
-                "/target:Clean",
-                "/property:Configuration=Release"
+                "/p:Configuration=Release",
+                "/p:GenerateFullPaths=true",
+                "/p:DebugType=portable",
+                "/m",
+                "/t:Clean",
+                "/v:m"
             ],
-            "problemMatcher": [
-                "$msCompile"
-            ]
+            "problemMatcher": "$msCompile"
         },
         {
-            "taskName": "Clean All",
+            "label": "Clean All",
             "dependsOn": [
                 "Clean (Debug)",
                 "Clean (Release)"
             ],
-            "problemMatcher": [
-                "$msCompile"
-            ]
+            "problemMatcher": "$msCompile"
         }
     ]
 }

appveyor.yml

@@ -9,17 +9,17 @@ cache:
   - inspectcode -> appveyor.yml
   - packages -> **\packages.config
 install:
-  - cmd: git submodule update --init --recursive
+  - cmd: git submodule update --init --recursive --depth=5
   - cmd: choco install resharper-clt -y
   - cmd: choco install nvika -y
   - cmd: appveyor DownloadFile https://github.com/peppy/CodeFileSanity/releases/download/v0.2.3/CodeFileSanity.exe
 before_build:
   - cmd: CodeFileSanity.exe
-  - cmd: nuget restore
+  - cmd: nuget restore -verbosity quiet
 build:
   project: osu.sln
   parallel: true
   verbosity: minimal
 after_build:
-  - cmd: inspectcode /o="inspectcodereport.xml" /caches-home="inspectcode" osu.sln
+  - cmd: inspectcode --o="inspectcodereport.xml" --projects:osu.Game* --caches-home="inspectcode" osu.sln > NUL
   - cmd: NVika parsereport "inspectcodereport.xml" --treatwarningsaserrors

osu.Desktop.Deploy/osu.Desktop.Deploy.csproj

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <Import Project="..\osu.Game.props" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -22,7 +22,6 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <LangVersion>6</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -102,9 +101,6 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="..\osu.licenseheader">
-      <Link>osu.licenseheader</Link>
-    </None>
     <None Include="App.config">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>

osu.Desktop/osu.Desktop.csproj

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0">
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="14.0">
+  <Import Project="..\osu.Game.props" />
   <PropertyGroup>
     <ProjectGuid>{419659FD-72EA-4678-9EB8-B22A746CED70}</ProjectGuid>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -62,7 +63,6 @@
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
     <Commandlineparameters>
     </Commandlineparameters>
-    <LangVersion>6</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>none</DebugType>
@@ -98,7 +98,6 @@
     <DebugType>full</DebugType>
     <PlatformTarget>AnyCPU</PlatformTarget>
     <UseVSHostingProcess>false</UseVSHostingProcess>
-    <LangVersion>6</LangVersion>
     <ErrorReport>prompt</ErrorReport>
     <StartArguments>--tests</StartArguments>
   </PropertyGroup>
@@ -174,9 +173,6 @@
     <Reference Include="System.Windows.Forms" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="..\osu.licenseheader">
-      <Link>osu.licenseheader</Link>
-    </None>
     <None Include="app.config" />
     <None Include="OpenTK.dll.config" />
     <None Include="osu!.res" />

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs

@@ -11,11 +11,11 @@ using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps
 {
-    internal class CatchBeatmapConverter : BeatmapConverter<CatchBaseHit>
+    internal class CatchBeatmapConverter : BeatmapConverter<CatchHitObject>
     {
         protected override IEnumerable<Type> ValidConversionTypes { get; } = new[] { typeof(IHasXPosition) };
 
-        protected override IEnumerable<CatchBaseHit> ConvertHitObject(HitObject obj, Beatmap beatmap)
+        protected override IEnumerable<CatchHitObject> ConvertHitObject(HitObject obj, Beatmap beatmap)
         {
             var curveData = obj as IHasCurve;
             var positionData = obj as IHasXPosition;

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapProcessor.cs

@@ -1,14 +1,20 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Objects.Types;
+using OpenTK;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps
 {
-    internal class CatchBeatmapProcessor : BeatmapProcessor<CatchBaseHit>
+    internal class CatchBeatmapProcessor : BeatmapProcessor<CatchHitObject>
     {
-        public override void PostProcess(Beatmap<CatchBaseHit> beatmap)
+        public override void PostProcess(Beatmap<CatchHitObject> beatmap)
         {
             if (beatmap.ComboColors.Count == 0)
                 return;
@@ -16,7 +22,9 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
             int comboIndex = 0;
             int colourIndex = 0;
 
-            CatchBaseHit lastObj = null;
+            CatchHitObject lastObj = null;
+
+            initialiseHyperDash(beatmap.HitObjects);
 
             foreach (var obj in beatmap.HitObjects)
             {
@@ -34,5 +42,49 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 lastObj = obj;
             }
         }
+
+        private void initialiseHyperDash(List<CatchHitObject> objects)
+        {
+            // todo: add difficulty adjust.
+            double halfCatcherWidth = CatcherArea.CATCHER_SIZE * (objects.FirstOrDefault()?.Scale ?? 1) / CatchPlayfield.BASE_WIDTH / 2;
+
+            int lastDirection = 0;
+            double lastExcess = halfCatcherWidth;
+
+            int objCount = objects.Count;
+
+            for (int i = 0; i < objCount - 1; i++)
+            {
+                CatchHitObject currentObject = objects[i];
+
+                // not needed?
+                // if (currentObject is TinyDroplet) continue;
+
+                CatchHitObject nextObject = objects[i + 1];
+
+                // while (nextObject is TinyDroplet)
+                // {
+                //     if (++i == objCount - 1) break;
+                //     nextObject = objects[i + 1];
+                // }
+
+                int thisDirection = nextObject.X > currentObject.X ? 1 : -1;
+                double timeToNext = nextObject.StartTime - ((currentObject as IHasEndTime)?.EndTime ?? currentObject.StartTime) - 4;
+                double distanceToNext = Math.Abs(nextObject.X - currentObject.X) - (lastDirection == thisDirection ? lastExcess : halfCatcherWidth);
+
+                if (timeToNext * CatcherArea.Catcher.BASE_SPEED < distanceToNext)
+                {
+                    currentObject.HyperDashTarget = nextObject;
+                    lastExcess = halfCatcherWidth;
+                }
+                else
+                {
+                    //currentObject.DistanceToHyperDash = timeToNext - distanceToNext;
+                    lastExcess = MathHelper.Clamp(timeToNext - distanceToNext, 0, halfCatcherWidth);
+                }
+
+                lastDirection = thisDirection;
+            }
+        }
     }
 }

osu.Game.Rulesets.Catch/CatchDifficultyCalculator.cs

@@ -8,14 +8,14 @@ using System.Collections.Generic;
 
 namespace osu.Game.Rulesets.Catch
 {
-    public class CatchDifficultyCalculator : DifficultyCalculator<CatchBaseHit>
+    public class CatchDifficultyCalculator : DifficultyCalculator<CatchHitObject>
     {
         public CatchDifficultyCalculator(Beatmap beatmap) : base(beatmap)
         {
         }
 
-        public override double Calculate(Dictionary<string, string> categoryDifficulty = null) => 0;
+        public override double Calculate(Dictionary<string, double> categoryDifficulty = null) => 0;
 
-        protected override BeatmapConverter<CatchBaseHit> CreateBeatmapConverter(Beatmap beatmap) => new CatchBeatmapConverter();
+        protected override BeatmapConverter<CatchHitObject> CreateBeatmapConverter(Beatmap beatmap) => new CatchBeatmapConverter();
     }
 }

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -93,6 +93,8 @@ namespace osu.Game.Rulesets.Catch
 
         public override string Description => "osu!catch";
 
+        public override string ShortName => "fruits";
+
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_fruits_o };
 
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new CatchDifficultyCalculator(beatmap);

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

@@ -1,24 +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 osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
-using OpenTK.Graphics;
-
-namespace osu.Game.Rulesets.Catch.Objects
-{
-    public abstract class CatchBaseHit : HitObject, IHasXPosition, IHasCombo
-    {
-        public float X { get; set; }
-
-        public Color4 ComboColour { get; set; } = Color4.Gray;
-        public int ComboIndex { get; set; }
-
-        public virtual bool NewCombo { get; set; }
-
-        /// <summary>
-        /// The next fruit starts a new combo. Used for explodey.
-        /// </summary>
-        public virtual bool LastInCombo { get; set; }
-    }
-}

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

@@ -0,0 +1,47 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.Objects
+{
+    public abstract class CatchHitObject : HitObject, IHasXPosition, IHasCombo
+    {
+        public const double OBJECT_RADIUS = 44;
+
+        public float X { get; set; }
+
+        public Color4 ComboColour { get; set; } = Color4.Gray;
+        public int ComboIndex { get; set; }
+
+        public virtual bool NewCombo { get; set; }
+
+        /// <summary>
+        /// The next fruit starts a new combo. Used for explodey.
+        /// </summary>
+        public virtual bool LastInCombo { get; set; }
+
+        public float Scale { get; set; } = 1;
+
+        /// <summary>
+        /// Whether this fruit can initiate a hyperdash.
+        /// </summary>
+        public bool HyperDash => HyperDashTarget != null;
+
+        /// <summary>
+        /// The target fruit if we are to initiate a hyperdash.
+        /// </summary>
+        public CatchHitObject HyperDashTarget;
+
+        public override void ApplyDefaults(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+        {
+            base.ApplyDefaults(controlPointInfo, difficulty);
+
+            Scale = 1.0f - 0.7f * (difficulty.CircleSize - 5) / 5;
+        }
+    }
+}

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

@@ -5,11 +5,12 @@ using System;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
+using OpenTK;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
     public abstract class DrawableCatchHitObject<TObject> : DrawableCatchHitObject
-        where TObject : CatchBaseHit
+        where TObject : CatchHitObject
     {
         public new TObject HitObject;
 
@@ -17,12 +18,14 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
             : base(hitObject)
         {
             HitObject = hitObject;
+
+            Scale = new Vector2(HitObject.Scale);
         }
     }
 
-    public abstract class DrawableCatchHitObject : DrawableScrollingHitObject<CatchBaseHit>
+    public abstract class DrawableCatchHitObject : DrawableScrollingHitObject<CatchHitObject>
     {
-        protected DrawableCatchHitObject(CatchBaseHit hitObject)
+        protected DrawableCatchHitObject(CatchHitObject hitObject)
             : base(hitObject)
         {
             RelativePositionAxes = Axes.Both;
@@ -30,7 +33,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
             Y = (float)HitObject.StartTime;
         }
 
-        public Func<CatchBaseHit, bool> CheckPosition;
+        public Func<CatchHitObject, bool> CheckPosition;
 
         protected override void CheckForJudgements(bool userTriggered, double timeOffset)
         {

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

@@ -7,6 +7,7 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
 using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
@@ -70,6 +71,20 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                     }
                 }
             };
+
+            if (HitObject.HyperDash)
+            {
+                Add(new Pulp
+                {
+                    RelativePositionAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    AccentColour = Color4.Red,
+                    Blending = BlendingMode.Additive,
+                    Alpha = 0.5f,
+                    Scale = new Vector2(2)
+                });
+            }
         }
     }
 }

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

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                 RelativeChildSize = new Vector2(1, (float)HitObject.Duration)
             };
 
-            foreach (CatchBaseHit tick in s.Ticks)
+            foreach (CatchHitObject tick in s.Ticks)
             {
                 TinyDroplet tiny = tick as TinyDroplet;
                 if (tiny != null)
@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
             }
         }
 
-        protected override void AddNested(DrawableHitObject<CatchBaseHit> h)
+        protected override void AddNested(DrawableHitObject<CatchHitObject> h)
         {
             ((DrawableCatchHitObject)h).CheckPosition = o => CheckPosition?.Invoke(o) ?? false;
             dropletContainer.Add(h);

osu.Game.Rulesets.Catch/Objects/Drawable/Pieces/Pulp.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable.Pieces
 {
     public class Pulp : Circle, IHasAccentColour
     {
-        public const float PULP_SIZE = 20;
+        public const float PULP_SIZE = (float)CatchHitObject.OBJECT_RADIUS / 2.2f;
 
         public Pulp()
         {

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

@@ -3,7 +3,7 @@
 
 namespace osu.Game.Rulesets.Catch.Objects
 {
-    public class Droplet : CatchBaseHit
+    public class Droplet : CatchHitObject
     {
     }
 }

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

@@ -3,7 +3,7 @@
 
 namespace osu.Game.Rulesets.Catch.Objects
 {
-    public class Fruit : CatchBaseHit
+    public class Fruit : CatchHitObject
     {
     }
 }

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

@@ -15,7 +15,7 @@ using osu.Framework.Lists;
 
 namespace osu.Game.Rulesets.Catch.Objects
 {
-    public class JuiceStream : CatchBaseHit, IHasCurve
+    public class JuiceStream : CatchHitObject, IHasCurve
     {
         /// <summary>
         /// Positional distance that results in a duration of one second, before any speed adjustments.
@@ -42,11 +42,11 @@ namespace osu.Game.Rulesets.Catch.Objects
             TickDistance = scoringDistance / difficulty.SliderTickRate;
         }
 
-        public IEnumerable<CatchBaseHit> Ticks
+        public IEnumerable<CatchHitObject> Ticks
         {
             get
             {
-                SortedList<CatchBaseHit> ticks = new SortedList<CatchBaseHit>((a, b) => a.StartTime.CompareTo(b.StartTime));
+                SortedList<CatchHitObject> ticks = new SortedList<CatchHitObject>((a, b) => a.StartTime.CompareTo(b.StartTime));
 
                 if (TickDistance == 0)
                     return ticks;

osu.Game.Rulesets.Catch/Scoring/CatchScoreProcessor.cs

@@ -10,14 +10,14 @@ using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Catch.Scoring
 {
-    internal class CatchScoreProcessor : ScoreProcessor<CatchBaseHit>
+    internal class CatchScoreProcessor : ScoreProcessor<CatchHitObject>
     {
-        public CatchScoreProcessor(RulesetContainer<CatchBaseHit> rulesetContainer)
+        public CatchScoreProcessor(RulesetContainer<CatchHitObject> rulesetContainer)
             : base(rulesetContainer)
         {
         }
 
-        protected override void SimulateAutoplay(Beatmap<CatchBaseHit> beatmap)
+        protected override void SimulateAutoplay(Beatmap<CatchHitObject> beatmap)
         {
             foreach (var obj in beatmap.HitObjects)
             {

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

@@ -11,16 +11,26 @@ namespace osu.Game.Rulesets.Catch.Tests
     [Ignore("getting CI working")]
     public class TestCaseCatchStacker : Game.Tests.Visual.TestCasePlayer
     {
-        public TestCaseCatchStacker() : base(typeof(CatchRuleset))
+        public TestCaseCatchStacker()
+            : base(typeof(CatchRuleset))
         {
         }
 
         protected override Beatmap CreateBeatmap()
         {
-            var beatmap = new Beatmap();
+            var beatmap = new Beatmap
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    BaseDifficulty = new BeatmapDifficulty
+                    {
+                        CircleSize = 6,
+                    }
+                }
+            };
 
-            for (int i = 0; i < 256; i++)
-                beatmap.HitObjects.Add(new Fruit { X = 0.5f, StartTime = i * 100, NewCombo = i % 8 == 0 });
+            for (int i = 0; i < 512; i++)
+                beatmap.HitObjects.Add(new Fruit { X = 0.5f + i / 2048f * (i % 10 - 5), StartTime = i * 100, NewCombo = i % 8 == 0 });
 
             return beatmap;
         }

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

@@ -1,44 +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 NUnit.Framework;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.UI;
-using osu.Game.Tests.Visual;
-using OpenTK;
-
-namespace osu.Game.Rulesets.Catch.Tests
-{
-    [TestFixture]
-    [Ignore("getting CI working")]
-    internal class TestCaseCatcher : OsuTestCase
-    {
-        public override IReadOnlyList<Type> RequiredTypes => new[]
-        {
-            typeof(Catcher),
-        };
-
-        [BackgroundDependencyLoader]
-        private void load(RulesetStore rulesets)
-        {
-            Children = new Drawable[]
-            {
-                new CatchInputManager(rulesets.GetRuleset(2))
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Child = new Catcher
-                    {
-                        RelativePositionAxes = Axes.Both,
-                        RelativeSizeAxes = Axes.Both,
-                        Anchor = Anchor.BottomLeft,
-                        Origin = Anchor.BottomLeft,
-                        Size = new Vector2(1, 0.2f),
-                    }
-                },
-            };
-        }
-    }
-}

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

@@ -0,0 +1,62 @@
+// 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 NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    [TestFixture]
+    [Ignore("getting CI working")]
+    public class TestCaseCatcherArea : OsuTestCase
+    {
+        private RulesetInfo catchRuleset;
+        private TestCatcherArea catcherArea;
+
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(CatcherArea),
+        };
+
+        public TestCaseCatcherArea()
+        {
+            AddSliderStep<float>("CircleSize", 0, 8, 5, createCatcher);
+            AddToggleStep("Hyperdash", t => catcherArea.ToggleHyperDash(t));
+        }
+
+        private void createCatcher(float size)
+        {
+            Child = new CatchInputManager(catchRuleset)
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = catcherArea = new TestCatcherArea(new BeatmapDifficulty { CircleSize = size })
+                {
+                    Anchor = Anchor.CentreLeft,
+                    Origin = Anchor.BottomLeft
+                },
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
+        {
+            catchRuleset = rulesets.GetRuleset(2);
+        }
+
+        private class TestCatcherArea : CatcherArea
+        {
+            public TestCatcherArea(BeatmapDifficulty beatmapDifficulty)
+                : base(beatmapDifficulty)
+            {
+            }
+
+            public void ToggleHyperDash(bool status) => MovableCatcher.HyperDashModifier = status ? 2 : 1;
+        }
+    }
+}

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

@@ -0,0 +1,30 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Objects;
+
+namespace osu.Game.Rulesets.Catch.Tests
+{
+    [TestFixture]
+    [Ignore("getting CI working")]
+    public class TestCaseHyperdash : Game.Tests.Visual.TestCasePlayer
+    {
+        public TestCaseHyperdash()
+            : base(typeof(CatchRuleset))
+        {
+        }
+
+        protected override Beatmap CreateBeatmap()
+        {
+            var beatmap = new Beatmap();
+
+            for (int i = 0; i < 512; i++)
+                if (i % 5 < 3)
+                    beatmap.HitObjects.Add(new Fruit { X = i % 10 < 5 ? 0.02f : 0.98f, StartTime = i * 100, NewCombo = i % 8 == 0 });
+
+            return beatmap;
+        }
+    }
+}

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

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

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

@@ -1,11 +1,11 @@
 // 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 osu.Framework.Graphics;
 using osu.Game.Rulesets.UI;
 using OpenTK;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Judgements;
@@ -15,15 +15,14 @@ namespace osu.Game.Rulesets.Catch.UI
 {
     public class CatchPlayfield : ScrollingPlayfield
     {
-        public static readonly float BASE_WIDTH = 512;
+        public const float BASE_WIDTH = 512;
 
         protected override Container<Drawable> Content => content;
         private readonly Container<Drawable> content;
 
-        private readonly Container catcherContainer;
-        private readonly Catcher catcher;
+        private readonly CatcherArea catcherArea;
 
-        public CatchPlayfield()
+        public CatchPlayfield(BeatmapDifficulty difficulty)
             : base(Axes.Y)
         {
             Container explodingFruitContainer;
@@ -43,30 +42,16 @@ namespace osu.Game.Rulesets.Catch.UI
                 {
                     RelativeSizeAxes = Axes.Both,
                 },
-                catcherContainer = new Container
+                catcherArea = new CatcherArea(difficulty)
                 {
-                    RelativeSizeAxes = Axes.X,
+                    ExplodingFruitTarget = explodingFruitContainer,
                     Anchor = Anchor.BottomLeft,
                     Origin = Anchor.TopLeft,
-                    Height = 180,
-                    Child = catcher = new Catcher
-                    {
-                        ExplodingFruitTarget = explodingFruitContainer,
-                        RelativePositionAxes = Axes.Both,
-                        Origin = Anchor.TopCentre,
-                        X = 0.5f,
-                    }
                 }
             };
         }
 
-        protected override void Update()
-        {
-            base.Update();
-            catcher.Size = new Vector2(catcherContainer.DrawSize.Y);
-        }
-
-        public bool CheckIfWeCanCatch(CatchBaseHit obj) => Math.Abs(catcher.Position.X - obj.X) < catcher.DrawSize.X / DrawSize.X / 2;
+        public bool CheckIfWeCanCatch(CatchHitObject obj) => catcherArea.AttemptCatch(obj);
 
         public override void Add(DrawableHitObject h)
         {
@@ -88,7 +73,7 @@ namespace osu.Game.Rulesets.Catch.UI
                 (judgedObject.Parent as Container<DrawableHitObject>)?.Remove(judgedObject);
                 (judgedObject.Parent as Container)?.Remove(judgedObject);
 
-                catcher.Add(judgedObject, screenPosition);
+                catcherArea.Add(judgedObject, screenPosition);
             }
         }
     }

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

@@ -13,7 +13,7 @@ using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
-    public class CatchRulesetContainer : ScrollingRulesetContainer<CatchPlayfield, CatchBaseHit>
+    public class CatchRulesetContainer : ScrollingRulesetContainer<CatchPlayfield, CatchHitObject>
     {
         public CatchRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
             : base(ruleset, beatmap, isForCurrentRuleset)
@@ -22,15 +22,15 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public override ScoreProcessor CreateScoreProcessor() => new CatchScoreProcessor(this);
 
-        protected override BeatmapProcessor<CatchBaseHit> CreateBeatmapProcessor() => new CatchBeatmapProcessor();
+        protected override BeatmapProcessor<CatchHitObject> CreateBeatmapProcessor() => new CatchBeatmapProcessor();
 
-        protected override BeatmapConverter<CatchBaseHit> CreateBeatmapConverter() => new CatchBeatmapConverter();
+        protected override BeatmapConverter<CatchHitObject> CreateBeatmapConverter() => new CatchBeatmapConverter();
 
-        protected override Playfield CreatePlayfield() => new CatchPlayfield();
+        protected override Playfield CreatePlayfield() => new CatchPlayfield(Beatmap.BeatmapInfo.BaseDifficulty);
 
         public override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
 
-        protected override DrawableHitObject<CatchBaseHit> GetVisualRepresentation(CatchBaseHit h)
+        protected override DrawableHitObject<CatchHitObject> GetVisualRepresentation(CatchHitObject h)
         {
             var fruit = h as Fruit;
             if (fruit != null)

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

@@ -1,193 +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.Linq;
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
-using osu.Framework.Input.Bindings;
-using osu.Framework.MathUtils;
-using osu.Game.Rulesets.Catch.Objects;
-using osu.Game.Rulesets.Objects.Drawables;
-using OpenTK;
-
-namespace osu.Game.Rulesets.Catch.UI
-{
-    public class Catcher : Container, IKeyBindingHandler<CatchAction>
-    {
-        private Texture texture;
-
-        private Container<DrawableHitObject> caughtFruit;
-
-        public Container ExplodingFruitTarget;
-
-        [BackgroundDependencyLoader]
-        private void load(TextureStore textures)
-        {
-            texture = textures.Get(@"Play/Catch/fruit-catcher-idle");
-
-            Children = new Drawable[]
-            {
-                createCatcherSprite(),
-                caughtFruit = new Container<DrawableHitObject>
-                {
-                    Anchor = Anchor.TopCentre,
-                    Origin = Anchor.BottomCentre,
-                }
-            };
-        }
-
-        private int currentDirection;
-
-        private bool dashing;
-
-        protected bool Dashing
-        {
-            get { return dashing; }
-            set
-            {
-                if (value == dashing) return;
-
-                dashing = value;
-
-                if (dashing)
-                    Schedule(addAdditiveSprite);
-            }
-        }
-
-        private void addAdditiveSprite()
-        {
-            if (!dashing) return;
-
-            var additive = createCatcherSprite();
-
-            additive.RelativePositionAxes = Axes.Both;
-            additive.Blending = BlendingMode.Additive;
-            additive.Position = Position;
-            additive.Scale = Scale;
-
-            ((Container)Parent).Add(additive);
-
-            additive.FadeTo(0.4f).FadeOut(800, Easing.OutQuint).Expire();
-
-            Scheduler.AddDelayed(addAdditiveSprite, 50);
-        }
-
-        private Sprite createCatcherSprite() => new Sprite
-        {
-            RelativeSizeAxes = Axes.Both,
-            FillMode = FillMode.Fit,
-            Texture = texture,
-            OriginPosition = new Vector2(DrawWidth / 2, 10) //temporary until the sprite is aligned correctly.
-        };
-
-        public bool OnPressed(CatchAction action)
-        {
-            switch (action)
-            {
-                case CatchAction.MoveLeft:
-                    currentDirection--;
-                    return true;
-                case CatchAction.MoveRight:
-                    currentDirection++;
-                    return true;
-                case CatchAction.Dash:
-                    Dashing = true;
-                    return true;
-            }
-
-            return false;
-        }
-
-        public bool OnReleased(CatchAction action)
-        {
-            switch (action)
-            {
-                case CatchAction.MoveLeft:
-                    currentDirection++;
-                    return true;
-                case CatchAction.MoveRight:
-                    currentDirection--;
-                    return true;
-                case CatchAction.Dash:
-                    Dashing = false;
-                    return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// The relative space to cover in 1 millisecond. based on 1 game pixel per millisecond as in osu-stable.
-        /// </summary>
-        private const double base_speed = 1.0 / 512;
-
-        protected override void Update()
-        {
-            base.Update();
-
-            if (currentDirection == 0) return;
-
-            double dashModifier = Dashing ? 1 : 0.5;
-
-            Scale = new Vector2(Math.Sign(currentDirection), 1);
-            X = (float)MathHelper.Clamp(X + Math.Sign(currentDirection) * Clock.ElapsedFrameTime * base_speed * dashModifier, 0, 1);
-        }
-
-        public void Add(DrawableHitObject fruit, Vector2 absolutePosition)
-        {
-            fruit.RelativePositionAxes = Axes.None;
-            fruit.Position = new Vector2(ToLocalSpace(absolutePosition).X - DrawSize.X / 2, 0);
-
-            fruit.Anchor = Anchor.TopCentre;
-            fruit.Origin = Anchor.BottomCentre;
-            fruit.Scale *= 0.7f;
-            fruit.LifetimeEnd = double.MaxValue;
-
-            float distance = fruit.DrawSize.X / 2 * fruit.Scale.X;
-
-            while (caughtFruit.Any(f => f.LifetimeEnd == double.MaxValue && Vector2Extensions.DistanceSquared(f.Position, fruit.Position) < distance * distance))
-            {
-                fruit.X += RNG.Next(-5, 5);
-                fruit.Y -= RNG.Next(0, 5);
-            }
-
-            caughtFruit.Add(fruit);
-
-            if (((CatchBaseHit)fruit.HitObject).LastInCombo)
-                explode();
-        }
-
-        private void explode()
-        {
-            var fruit = caughtFruit.ToArray();
-
-            foreach (var f in fruit)
-            {
-                var originalX = f.X * Scale.X;
-
-                if (ExplodingFruitTarget != null)
-                {
-                    f.Anchor = Anchor.TopLeft;
-                    f.Position = caughtFruit.ToSpaceOfOtherDrawable(f.DrawPosition, ExplodingFruitTarget);
-
-                    caughtFruit.Remove(f);
-
-                    ExplodingFruitTarget.Add(f);
-                }
-
-                f.MoveToY(f.Y - 50, 250, Easing.OutSine)
-                .Then()
-                .MoveToY(f.Y + 50, 500, Easing.InSine);
-
-                f.MoveToX(f.X + originalX * 6, 1000);
-                f.FadeOut(750);
-
-                f.Expire();
-            }
-        }
-    }
-}

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

@@ -0,0 +1,342 @@
+// 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.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Input.Bindings;
+using osu.Framework.MathUtils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class CatcherArea : Container
+    {
+        public const float CATCHER_SIZE = 172;
+
+        protected readonly Catcher MovableCatcher;
+
+        public Container ExplodingFruitTarget
+        {
+            set { MovableCatcher.ExplodingFruitTarget = value; }
+        }
+
+        public CatcherArea(BeatmapDifficulty difficulty = null)
+        {
+            RelativeSizeAxes = Axes.X;
+            Height = CATCHER_SIZE;
+            Child = MovableCatcher = new Catcher(difficulty)
+            {
+                AdditiveTarget = this,
+            };
+        }
+
+        public void Add(DrawableHitObject fruit, Vector2 absolutePosition)
+        {
+            fruit.RelativePositionAxes = Axes.None;
+            fruit.Position = new Vector2(MovableCatcher.ToLocalSpace(absolutePosition).X - MovableCatcher.DrawSize.X / 2, 0);
+
+            fruit.Anchor = Anchor.TopCentre;
+            fruit.Origin = Anchor.BottomCentre;
+            fruit.Scale *= 0.7f;
+            fruit.LifetimeEnd = double.MaxValue;
+
+            MovableCatcher.Add(fruit);
+        }
+
+        public bool AttemptCatch(CatchHitObject obj) => MovableCatcher.AttemptCatch(obj);
+
+        public class Catcher : Container, IKeyBindingHandler<CatchAction>
+        {
+            private Texture texture;
+
+            private Container<DrawableHitObject> caughtFruit;
+
+            public Container ExplodingFruitTarget;
+
+            public Container AdditiveTarget;
+
+            public Catcher(BeatmapDifficulty difficulty = null)
+            {
+                RelativePositionAxes = Axes.X;
+                X = 0.5f;
+
+                Origin = Anchor.TopCentre;
+                Anchor = Anchor.TopLeft;
+
+                Size = new Vector2(CATCHER_SIZE);
+                if (difficulty != null)
+                    Scale = new Vector2(1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(TextureStore textures)
+            {
+                texture = textures.Get(@"Play/Catch/fruit-catcher-idle");
+
+                Children = new Drawable[]
+                {
+                    createCatcherSprite(),
+                    caughtFruit = new Container<DrawableHitObject>
+                    {
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.BottomCentre,
+                    }
+                };
+            }
+
+            private int currentDirection;
+
+            private bool dashing;
+
+            protected bool Dashing
+            {
+                get { return dashing; }
+                set
+                {
+                    if (value == dashing) return;
+
+                    dashing = value;
+
+                    Trail |= dashing;
+                }
+            }
+
+            private bool trail;
+
+            /// <summary>
+            /// Activate or deactive the trail. Will be automatically deactivated when conditions to keep the trail displayed are no longer met.
+            /// </summary>
+            protected bool Trail
+            {
+                get { return trail; }
+                set
+                {
+                    if (value == trail) return;
+
+                    trail = value;
+
+                    if (Trail)
+                        beginTrail();
+                }
+            }
+
+            private void beginTrail()
+            {
+                Trail &= dashing || HyperDashing;
+                Trail &= AdditiveTarget != null;
+
+                if (!Trail) return;
+
+                var additive = createCatcherSprite();
+
+                additive.Anchor = Anchor;
+                additive.OriginPosition = additive.OriginPosition + new Vector2(DrawWidth / 2, 0); // also temporary to align sprite correctly.
+                additive.Position = Position;
+                additive.Scale = Scale;
+                additive.Colour = HyperDashing ? Color4.Red : Color4.White;
+                additive.RelativePositionAxes = RelativePositionAxes;
+                additive.Blending = BlendingMode.Additive;
+
+                AdditiveTarget.Add(additive);
+
+                additive.FadeTo(0.4f).FadeOut(800, Easing.OutQuint).Expire();
+
+                Scheduler.AddDelayed(beginTrail, HyperDashing ? 25 : 50);
+            }
+
+            private Sprite createCatcherSprite() => new Sprite
+            {
+                Size = new Vector2(CATCHER_SIZE),
+                FillMode = FillMode.Fill,
+                Texture = texture,
+                OriginPosition = new Vector2(-3, 10) // temporary until the sprite is aligned correctly.
+            };
+
+            /// <summary>
+            /// Add a caught fruit to the catcher's stack.
+            /// </summary>
+            /// <param name="fruit">The fruit that was caught.</param>
+            public void Add(DrawableHitObject fruit)
+            {
+                float distance = fruit.DrawSize.X / 2 * fruit.Scale.X;
+
+                while (caughtFruit.Any(f => f.LifetimeEnd == double.MaxValue && Vector2Extensions.DistanceSquared(f.Position, fruit.Position) < distance * distance))
+                {
+                    fruit.X += RNG.Next(-5, 5);
+                    fruit.Y -= RNG.Next(0, 5);
+                }
+
+                caughtFruit.Add(fruit);
+
+                var catchObject = (CatchHitObject)fruit.HitObject;
+
+                if (catchObject.LastInCombo)
+                    explode();
+            }
+
+            /// <summary>
+            /// Let the catcher attempt to catch a fruit.
+            /// </summary>
+            /// <param name="fruit">The fruit to catch.</param>
+            /// <returns>Whether the catch is possible.</returns>
+            public bool AttemptCatch(CatchHitObject fruit)
+            {
+                const double relative_catcher_width = CATCHER_SIZE / 2;
+
+                // this stuff wil disappear once we move fruit to non-relative coordinate space in the future.
+                var catchObjectPosition = fruit.X * CatchPlayfield.BASE_WIDTH;
+                var catcherPosition = Position.X * CatchPlayfield.BASE_WIDTH;
+
+                var validCatch =
+                    catchObjectPosition >= catcherPosition - relative_catcher_width / 2 &&
+                    catchObjectPosition <= catcherPosition + relative_catcher_width / 2;
+
+                if (validCatch && fruit.HyperDash)
+                {
+                    HyperDashModifier = Math.Abs(fruit.HyperDashTarget.X - fruit.X) / Math.Abs(fruit.HyperDashTarget.StartTime - fruit.StartTime) / BASE_SPEED;
+                    HyperDashDirection = fruit.HyperDashTarget.X - fruit.X;
+                }
+                else
+                    HyperDashModifier = 1;
+
+                return validCatch;
+            }
+
+            /// <summary>
+            /// Whether we are hypderdashing or not.
+            /// </summary>
+            public bool HyperDashing => hyperDashModifier != 1;
+
+            private double hyperDashModifier = 1;
+
+            /// <summary>
+            /// The direction in which hyperdash is allowed. 0 allows both directions.
+            /// </summary>
+            public double HyperDashDirection;
+
+            /// <summary>
+            /// The speed modifier resultant from hyperdash. Will trigger hyperdash when not equal to 1.
+            /// </summary>
+            public double HyperDashModifier
+            {
+                get { return hyperDashModifier; }
+                set
+                {
+                    if (value == hyperDashModifier) return;
+                    hyperDashModifier = value;
+
+                    const float transition_length = 180;
+
+                    if (HyperDashing)
+                    {
+                        this.FadeColour(Color4.OrangeRed, transition_length, Easing.OutQuint);
+                        this.FadeTo(0.2f, transition_length, Easing.OutQuint);
+                        Trail = true;
+                    }
+                    else
+                    {
+                        HyperDashDirection = 0;
+                        this.FadeColour(Color4.White, transition_length, Easing.OutQuint);
+                        this.FadeTo(1, transition_length, Easing.OutQuint);
+                    }
+                }
+            }
+
+            public bool OnPressed(CatchAction action)
+            {
+                switch (action)
+                {
+                    case CatchAction.MoveLeft:
+                        currentDirection--;
+                        return true;
+                    case CatchAction.MoveRight:
+                        currentDirection++;
+                        return true;
+                    case CatchAction.Dash:
+                        Dashing = true;
+                        return true;
+                }
+
+                return false;
+            }
+
+            public bool OnReleased(CatchAction action)
+            {
+                switch (action)
+                {
+                    case CatchAction.MoveLeft:
+                        currentDirection++;
+                        return true;
+                    case CatchAction.MoveRight:
+                        currentDirection--;
+                        return true;
+                    case CatchAction.Dash:
+                        Dashing = false;
+                        return true;
+                }
+
+                return false;
+            }
+
+            /// <summary>
+            /// The relative space to cover in 1 millisecond. based on 1 game pixel per millisecond as in osu-stable.
+            /// </summary>
+            public const double BASE_SPEED = 1.0 / 512;
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (currentDirection == 0) return;
+
+                var direction = Math.Sign(currentDirection);
+
+                double dashModifier = Dashing ? 1 : 0.5;
+
+                if (hyperDashModifier != 1 && (HyperDashDirection == 0 || direction == Math.Sign(HyperDashDirection)))
+                    dashModifier = hyperDashModifier;
+
+                Scale = new Vector2(Math.Abs(Scale.X) * direction, Scale.Y);
+                X = (float)MathHelper.Clamp(X + direction * Clock.ElapsedFrameTime * BASE_SPEED * dashModifier, 0, 1);
+            }
+
+            private void explode()
+            {
+                var fruit = caughtFruit.ToArray();
+
+                foreach (var f in fruit)
+                {
+                    var originalX = f.X * Scale.X;
+
+                    if (ExplodingFruitTarget != null)
+                    {
+                        f.Anchor = Anchor.TopLeft;
+                        f.Position = caughtFruit.ToSpaceOfOtherDrawable(f.DrawPosition, ExplodingFruitTarget);
+
+                        caughtFruit.Remove(f);
+
+                        ExplodingFruitTarget.Add(f);
+                    }
+
+                    f.MoveToY(f.Y - 50, 250, Easing.OutSine)
+                     .Then()
+                     .MoveToY(f.Y + 50, 500, Easing.InSine);
+
+                    f.MoveToX(f.X + originalX * 6, 1000);
+                    f.FadeOut(750);
+
+                    f.Expire();
+                }
+            }
+        }
+    }
+}

osu.Game.Rulesets.Catch/osu.Game.Rulesets.Catch.csproj

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <Import Project="..\osu.Game.props" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -21,7 +21,6 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
-    <LangVersion>6</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -57,25 +56,24 @@
     <Compile Include="Objects\JuiceStream.cs" />
     <Compile Include="Scoring\CatchScoreProcessor.cs" />
     <Compile Include="Judgements\CatchJudgement.cs" />
-    <Compile Include="Objects\CatchBaseHit.cs" />
+    <Compile Include="Objects\CatchHitObject.cs" />
     <Compile Include="Objects\Drawable\DrawableFruit.cs" />
     <Compile Include="Objects\Droplet.cs" />
     <Compile Include="Objects\Fruit.cs" />
     <Compile Include="Objects\TinyDroplet.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Tests\TestCaseCatcher.cs" />
+    <Compile Include="Tests\TestCaseCatcherArea.cs" />
     <Compile Include="Tests\TestCaseCatchStacker.cs" />
+    <Compile Include="Tests\TestCasePerformancePoints.cs" />
     <Compile Include="Tests\TestCaseCatchPlayer.cs" />
-    <Compile Include="UI\Catcher.cs" />
+    <Compile Include="Tests\TestCaseHyperdash.cs" />
+    <Compile Include="UI\CatcherArea.cs" />
     <Compile Include="UI\CatchRulesetContainer.cs" />
     <Compile Include="UI\CatchPlayfield.cs" />
     <Compile Include="CatchRuleset.cs" />
     <Compile Include="Mods\CatchMod.cs" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="..\osu.licenseheader">
-      <Link>osu.licenseheader</Link>
-    </None>
     <None Include="app.config" />
     <None Include="OpenTK.dll.config" />
     <None Include="packages.config" />
@@ -92,6 +90,9 @@
       <Private>True</Private>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.

osu.Game.Rulesets.Mania/ManiaDifficultyCalculator.cs

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Mania
         {
         }
 
-        public override double Calculate(Dictionary<string, string> categoryDifficulty = null) => 0;
+        public override double Calculate(Dictionary<string, double> categoryDifficulty = null) => 0;
 
         protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter(Beatmap beatmap) => new ManiaBeatmapConverter(true, (int)Math.Max(1, Math.Round(beatmap.BeatmapInfo.BaseDifficulty.CircleSize)));
     }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -105,6 +105,8 @@ namespace osu.Game.Rulesets.Mania
 
         public override string Description => "osu!mania";
 
+        public override string ShortName => "mania";
+
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_mania_o };
 
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new ManiaDifficultyCalculator(beatmap);

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

@@ -176,22 +176,10 @@ namespace osu.Game.Rulesets.Mania.Mods
 
     public class ManiaModAutoplay : ModAutoplay<ManiaHitObject>
     {
-        private int availableColumns;
-
-        public override void ApplyToRulesetContainer(RulesetContainer<ManiaHitObject> rulesetContainer)
-        {
-            // Todo: This shouldn't be done, we should be getting a ManiaBeatmap which should store AvailableColumns
-            // But this is dependent on a _lot_ of refactoring
-            var maniaRulesetContainer = (ManiaRulesetContainer)rulesetContainer;
-            availableColumns = maniaRulesetContainer.AvailableColumns;
-
-            base.ApplyToRulesetContainer(rulesetContainer);
-        }
-
         protected override Score CreateReplayScore(Beatmap<ManiaHitObject> beatmap) => new Score
         {
             User = new User { Username = "osu!topus!" },
-            Replay = new ManiaAutoGenerator(beatmap, availableColumns).Generate(),
+            Replay = new ManiaAutoGenerator(beatmap).Generate(),
         };
     }
 }

osu.Game.Rulesets.Mania/Replays/ManiaAutoGenerator.cs

@@ -1,7 +1,7 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System;
+using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
@@ -13,15 +13,11 @@ namespace osu.Game.Rulesets.Mania.Replays
 {
     internal class ManiaAutoGenerator : AutoGenerator<ManiaHitObject>
     {
-        private const double release_delay = 20;
+        public const double RELEASE_DELAY = 20;
 
-        private readonly int availableColumns;
-
-        public ManiaAutoGenerator(Beatmap<ManiaHitObject> beatmap, int availableColumns)
+        public ManiaAutoGenerator(Beatmap<ManiaHitObject> beatmap)
             : base(beatmap)
         {
-            this.availableColumns = availableColumns;
-
             Replay = new Replay { User = new User { Username = @"Autoplay" } };
         }
 
@@ -30,104 +26,52 @@ namespace osu.Game.Rulesets.Mania.Replays
         public override Replay Generate()
         {
             // Todo: Realistically this shouldn't be needed, but the first frame is skipped with the way replays are currently handled
-            Replay.Frames.Add(new ReplayFrame(-100000, null, null, ReplayButtonState.None));
+            Replay.Frames.Add(new ManiaReplayFrame(-100000, 0));
 
-            double[] holdEndTimes = new double[availableColumns];
-            for (int i = 0; i < availableColumns; i++)
-                holdEndTimes[i] = double.NegativeInfinity;
+            var pointGroups = generateActionPoints().GroupBy(a => a.Time).OrderBy(g => g.First().Time);
 
-            // Notes are handled row-by-row
-            foreach (var objGroup in Beatmap.HitObjects.GroupBy(h => h.StartTime))
+            int activeColumns = 0;
+            foreach (var group in pointGroups)
             {
-                double groupTime = objGroup.Key;
-
-                int activeColumns = 0;
-
-                // Get the previously held-down active columns
-                for (int i = 0; i < availableColumns; i++)
+                foreach (var point in group)
                 {
-                    if (holdEndTimes[i] > groupTime)
-                        activeColumns |= 1 << i;
+                    if (point is HitPoint)
+                        activeColumns |= 1 << point.Column;
+                    if (point is ReleasePoint)
+                        activeColumns ^= 1 << point.Column;
                 }
 
-                // Add on the group columns, keeping track of the held notes for the next rows
-                foreach (var obj in objGroup)
-                {
-                    var holdNote = obj as HoldNote;
-                    if (holdNote != null)
-                        holdEndTimes[obj.Column] = Math.Max(holdEndTimes[obj.Column], holdNote.EndTime);
-
-                    activeColumns |= 1 << obj.Column;
-                }
-
-                Replay.Frames.Add(new ReplayFrame(groupTime, activeColumns, null, ReplayButtonState.None));
-
-                // Add the release frames. We can't do this with the loop above because we need activeColumns to be fully populated
-                foreach (var obj in objGroup.GroupBy(h => (h as IHasEndTime)?.EndTime ?? h.StartTime + release_delay).OrderBy(h => h.Key))
-                {
-                    var groupEndTime = obj.Key;
-
-                    int activeColumnsAtEnd = 0;
-                    for (int i = 0; i < availableColumns; i++)
-                    {
-                        if (holdEndTimes[i] > groupEndTime)
-                            activeColumnsAtEnd |= 1 << i;
-                    }
-
-                    Replay.Frames.Add(new ReplayFrame(groupEndTime, activeColumnsAtEnd, 0, ReplayButtonState.None));
-                }
+                Replay.Frames.Add(new ManiaReplayFrame(group.First().Time, activeColumns));
             }
 
-            Replay.Frames = Replay.Frames
-                                  // Pick the maximum activeColumns for all frames at the same time
-                                  .GroupBy(f => f.Time)
-                                  .Select(g => new ReplayFrame(g.First().Time, maxMouseX(g), 0, ReplayButtonState.None))
-                                  // The addition of release frames above maybe result in unordered frames, but we need them ordered
-                                  .OrderBy(f => f.Time)
-                                  .ToList();
-
             return Replay;
         }
 
-        /// <summary>
-        /// Finds the maximum <see cref="ReplayFrame.MouseX"/> by count of bits from a grouping of <see cref="ReplayFrame"/>s.
-        /// </summary>
-        /// <param name="group">The <see cref="ReplayFrame"/> grouping to search.</param>
-        /// <returns>The maximum <see cref="ReplayFrame.MouseX"/> by count of bits.</returns>
-        private float maxMouseX(IGrouping<double, ReplayFrame> group)
+        private IEnumerable<IActionPoint> generateActionPoints()
         {
-            int currentCount = -1;
-            int currentMax = 0;
-
-            foreach (var val in group)
+            foreach (var obj in Beatmap.HitObjects)
             {
-                int newCount = countBits((int)(val.MouseX ?? 0));
-                if (newCount > currentCount)
-                {
-                    currentCount = newCount;
-                    currentMax = (int)(val.MouseX ?? 0);
-                }
+                yield return new HitPoint { Time = obj.StartTime, Column = obj.Column };
+                yield return new ReleasePoint { Time = ((obj as IHasEndTime)?.EndTime ?? obj.StartTime) + RELEASE_DELAY, Column = obj.Column };
             }
-
-            return currentMax;
         }
 
-        /// <summary>
-        /// Counts the number of bits set in a value.
-        /// </summary>
-        /// <param name="value">The value to count.</param>
-        /// <returns>The number of set bits.</returns>
-        private int countBits(int value)
+        private interface IActionPoint
         {
-            int count = 0;
-            while (value > 0)
-            {
-                if ((value & 1) > 0)
-                    count++;
-                value >>= 1;
-            }
+            double Time { get; set; }
+            int Column { get; set; }
+        }
 
-            return count;
+        private struct HitPoint : IActionPoint
+        {
+            public double Time { get; set; }
+            public int Column { get; set; }
+        }
+
+        private struct ReleasePoint : IActionPoint
+        {
+            public double Time { get; set; }
+            public int Column { get; set; }
         }
     }
 }

osu.Game.Rulesets.Mania/Replays/ManiaFramedReplayInputHandler.cs

@@ -2,29 +2,37 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Input;
+using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Replays;
 
 namespace osu.Game.Rulesets.Mania.Replays
 {
     internal class ManiaFramedReplayInputHandler : FramedReplayInputHandler
     {
-        public ManiaFramedReplayInputHandler(Replay replay)
+        private readonly ManiaRulesetContainer container;
+
+        public ManiaFramedReplayInputHandler(Replay replay, ManiaRulesetContainer container)
             : base(replay)
         {
+            this.container = container;
         }
 
+        private ManiaPlayfield playfield;
         public override List<InputState> GetPendingStates()
         {
             var actions = new List<ManiaAction>();
 
-            int activeColumns = (int)(CurrentFrame.MouseX ?? 0);
+            if (playfield == null)
+                playfield = (ManiaPlayfield)container.Playfield;
 
+            int activeColumns = (int)(CurrentFrame.MouseX ?? 0);
             int counter = 0;
             while (activeColumns > 0)
             {
                 if ((activeColumns & 1) > 0)
-                    actions.Add(ManiaAction.Key1 + counter);
+                    actions.Add(playfield.Columns.ElementAt(counter).Action);
                 counter++;
                 activeColumns >>= 1;
             }

osu.Game.Rulesets.Mania/Replays/ManiaReplayFrame.cs

@@ -0,0 +1,17 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Replays;
+
+namespace osu.Game.Rulesets.Mania.Replays
+{
+    public class ManiaReplayFrame : ReplayFrame
+    {
+        public override bool IsImportant => MouseX > 0;
+
+        public ManiaReplayFrame(double time, int activeColumns)
+            : base(time, activeColumns, null, ReplayButtonState.None)
+        {
+        }
+    }
+}

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

@@ -0,0 +1,173 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    [Ignore("getting CI working")]
+    public class TestCaseAutoGeneration : OsuTestCase
+    {
+        [Test]
+        public void TestSingleNote()
+        {
+            // |   |
+            // | - |
+            // |   |
+
+            var beatmap = new Beatmap<ManiaHitObject>();
+            beatmap.HitObjects.Add(new Note { StartTime = 1000 });
+
+            var generated = new ManiaAutoGenerator(beatmap).Generate();
+
+            Assert.IsTrue(generated.Frames.Count == 3, "Replay must have 3 frames");
+            Assert.AreEqual(1000, generated.Frames[1].Time, "Incorrect hit time");
+            Assert.AreEqual(1000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[2].Time, "Incorrect release time");
+            Assert.AreEqual(1, generated.Frames[1].MouseX, "Key 0 has not been pressed");
+            Assert.AreEqual(0, generated.Frames[2].MouseX, "Key 0 has not been released");
+        }
+
+        [Test]
+        public void TestSingleHoldNote()
+        {
+            // |   |
+            // | * |
+            // | * |
+            // | * |
+            // |   |
+
+            var beatmap = new Beatmap<ManiaHitObject>();
+            beatmap.HitObjects.Add(new HoldNote { StartTime = 1000, Duration = 2000 });
+
+            var generated = new ManiaAutoGenerator(beatmap).Generate();
+
+            Assert.IsTrue(generated.Frames.Count == 3, "Replay must have 3 frames");
+            Assert.AreEqual(1000, generated.Frames[1].Time, "Incorrect hit time");
+            Assert.AreEqual(3000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[2].Time, "Incorrect release time");
+            Assert.AreEqual(1, generated.Frames[1].MouseX, "Key 0 has not been pressed");
+            Assert.AreEqual(0, generated.Frames[2].MouseX, "Key 0 has not been released");
+        }
+
+        [Test]
+        public void TestSingleNoteChord()
+        {
+            // |   |   |
+            // | - | - |
+            // |   |   |
+
+            var beatmap = new Beatmap<ManiaHitObject>();
+            beatmap.HitObjects.Add(new Note { StartTime = 1000 });
+            beatmap.HitObjects.Add(new Note { StartTime = 1000, Column = 1 });
+
+            var generated = new ManiaAutoGenerator(beatmap).Generate();
+
+            Assert.IsTrue(generated.Frames.Count == 3, "Replay must have 3 frames");
+            Assert.AreEqual(1000, generated.Frames[1].Time, "Incorrect hit time");
+            Assert.AreEqual(1000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[2].Time, "Incorrect release time");
+            Assert.AreEqual(3, generated.Frames[1].MouseX, "Keys 1 and 2 have not been pressed");
+            Assert.AreEqual(0, generated.Frames[2].MouseX, "Keys 1 and 2 have not been released");
+        }
+
+        [Test]
+        public void TestHoldNoteChord()
+        {
+            // |   |   |
+            // | * | * |
+            // | * | * |
+            // | * | * |
+            // |   |   |
+
+            var beatmap = new Beatmap<ManiaHitObject>();
+            beatmap.HitObjects.Add(new HoldNote { StartTime = 1000, Duration = 2000 });
+            beatmap.HitObjects.Add(new HoldNote { StartTime = 1000, Duration = 2000, Column = 1 });
+
+            var generated = new ManiaAutoGenerator(beatmap).Generate();
+
+            Assert.IsTrue(generated.Frames.Count == 3, "Replay must have 3 frames");
+            Assert.AreEqual(1000, generated.Frames[1].Time, "Incorrect hit time");
+            Assert.AreEqual(3000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[2].Time, "Incorrect release time");
+            Assert.AreEqual(3, generated.Frames[1].MouseX, "Keys 1 and 2 have not been pressed");
+            Assert.AreEqual(0, generated.Frames[2].MouseX, "Keys 1 and 2 have not been released");
+        }
+
+        [Test]
+        public void TestSingleNoteStair()
+        {
+            // |   |   |
+            // |   | - |
+            // | - |   |
+            // |   |   |
+
+            var beatmap = new Beatmap<ManiaHitObject>();
+            beatmap.HitObjects.Add(new Note { StartTime = 1000 });
+            beatmap.HitObjects.Add(new Note { StartTime = 2000, Column = 1 });
+
+            var generated = new ManiaAutoGenerator(beatmap).Generate();
+
+            Assert.IsTrue(generated.Frames.Count == 5, "Replay must have 5 frames");
+            Assert.AreEqual(1000, generated.Frames[1].Time, "Incorrect first note hit time");
+            Assert.AreEqual(1000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[2].Time, "Incorrect first note release time");
+            Assert.AreEqual(2000, generated.Frames[3].Time, "Incorrect second note hit time");
+            Assert.AreEqual(2000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[4].Time, "Incorrect second note release time");
+            Assert.AreEqual(1, generated.Frames[1].MouseX, "Key 1 has not been pressed");
+            Assert.AreEqual(0, generated.Frames[2].MouseX, "Key 1 has not been released");
+            Assert.AreEqual(2, generated.Frames[3].MouseX, "Key 2 has not been pressed");
+            Assert.AreEqual(0, generated.Frames[4].MouseX, "Key 2 has not been released");
+        }
+
+        [Test]
+        public void TestHoldNoteStair()
+        {
+            // |   |   |
+            // |   | * |
+            // | * | * |
+            // | * | * |
+            // | * |   |
+            // |   |   |
+
+            var beatmap = new Beatmap<ManiaHitObject>();
+            beatmap.HitObjects.Add(new HoldNote { StartTime = 1000, Duration = 2000 });
+            beatmap.HitObjects.Add(new HoldNote { StartTime = 2000, Duration = 2000, Column = 1 });
+
+            var generated = new ManiaAutoGenerator(beatmap).Generate();
+
+            Assert.IsTrue(generated.Frames.Count == 5, "Replay must have 5 frames");
+            Assert.AreEqual(1000, generated.Frames[1].Time, "Incorrect first note hit time");
+            Assert.AreEqual(3000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[3].Time, "Incorrect first note release time");
+            Assert.AreEqual(2000, generated.Frames[2].Time, "Incorrect second note hit time");
+            Assert.AreEqual(4000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[4].Time, "Incorrect second note release time");
+            Assert.AreEqual(1, generated.Frames[1].MouseX, "Key 1 has not been pressed");
+            Assert.AreEqual(3, generated.Frames[2].MouseX, "Keys 1 and 2 have not been pressed");
+            Assert.AreEqual(2, generated.Frames[3].MouseX, "Key 1 has not been released");
+            Assert.AreEqual(0, generated.Frames[4].MouseX, "Key 2 has not been released");
+        }
+
+        [Test]
+        public void TestHoldNoteWithReleasePress()
+        {
+            // |   |   |
+            // | * | - |
+            // | * |   |
+            // | * |   |
+            // |   |   |
+
+            var beatmap = new Beatmap<ManiaHitObject>();
+            beatmap.HitObjects.Add(new HoldNote { StartTime = 1000, Duration = 2000 - ManiaAutoGenerator.RELEASE_DELAY });
+            beatmap.HitObjects.Add(new Note { StartTime = 3000, Column = 1 });
+
+            var generated = new ManiaAutoGenerator(beatmap).Generate();
+
+            Assert.IsTrue(generated.Frames.Count == 4, "Replay must have 4 frames");
+            Assert.AreEqual(1000, generated.Frames[1].Time, "Incorrect first note hit time");
+            Assert.AreEqual(3000, generated.Frames[2].Time, "Incorrect second note press time + first note release time");
+            Assert.AreEqual(3000 + ManiaAutoGenerator.RELEASE_DELAY, generated.Frames[3].Time, "Incorrect second note release time");
+            Assert.AreEqual(1, generated.Frames[1].MouseX, "Key 1 has not been pressed");
+            Assert.AreEqual(2, generated.Frames[2].MouseX, "Key 1 has not been released or key 2 has not been pressed");
+            Assert.AreEqual(0, generated.Frames[3].MouseX, "Keys 1 and 2 have not been released");
+        }
+    }
+}

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

@@ -14,7 +14,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 {
     [TestFixture]
     [Ignore("getting CI working")]
-    internal class TestCaseManiaHitObjects : OsuTestCase
+    public class TestCaseManiaHitObjects : OsuTestCase
     {
         public TestCaseManiaHitObjects()
         {

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

@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 {
     [TestFixture]
     [Ignore("getting CI working")]
-    internal class TestCaseManiaPlayfield : OsuTestCase
+    public class TestCaseManiaPlayfield : OsuTestCase
     {
         private const double start_time = 500;
         private const double duration = 500;

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

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

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

@@ -124,6 +124,6 @@ namespace osu.Game.Rulesets.Mania.UI
 
         protected override SpeedAdjustmentContainer CreateSpeedAdjustmentContainer(MultiplierControlPoint controlPoint) => new ManiaSpeedAdjustmentContainer(controlPoint, ScrollingAlgorithm.Basic);
 
-        protected override FramedReplayInputHandler CreateReplayInputHandler(Replay replay) => new ManiaFramedReplayInputHandler(replay);
+        protected override FramedReplayInputHandler CreateReplayInputHandler(Replay replay) => new ManiaFramedReplayInputHandler(replay, this);
     }
 }

osu.Game.Rulesets.Mania/osu.Game.Rulesets.Mania.csproj

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <Import Project="..\osu.Game.props" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -21,7 +21,6 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
-    <LangVersion>6</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -72,6 +71,7 @@
     <Compile Include="Objects\Types\IHasColumn.cs" />
     <Compile Include="Replays\ManiaAutoGenerator.cs" />
     <Compile Include="Replays\ManiaFramedReplayInputHandler.cs" />
+    <Compile Include="Replays\ManiaReplayFrame.cs" />
     <Compile Include="Scoring\ManiaScoreProcessor.cs" />
     <Compile Include="Objects\BarLine.cs" />
     <Compile Include="Objects\HoldNote.cs" />
@@ -80,8 +80,10 @@
     <Compile Include="Objects\Note.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ManiaInputManager.cs" />
+    <Compile Include="Tests\TestCaseAutoGeneration.cs" />
     <Compile Include="Tests\TestCaseManiaHitObjects.cs" />
     <Compile Include="Tests\TestCaseManiaPlayfield.cs" />
+    <Compile Include="Tests\TestCasePerformancePoints.cs" />
     <Compile Include="Timing\GravityScrollingContainer.cs" />
     <Compile Include="Timing\ScrollingAlgorithm.cs" />
     <Compile Include="UI\Column.cs" />
@@ -96,9 +98,6 @@
     <Compile Include="Timing\ManiaSpeedAdjustmentContainer.cs" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="..\osu.licenseheader">
-      <Link>osu.licenseheader</Link>
-    </None>
     <None Include="app.config" />
     <None Include="OpenTK.dll.config" />
     <None Include="packages.config" />
@@ -115,6 +114,9 @@
       <Private>True</Private>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.

osu.Game.Rulesets.Osu/Edit/OsuEditPlayfield.cs

@@ -0,0 +1,13 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics.Cursor;
+using osu.Game.Rulesets.Osu.UI;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class OsuEditPlayfield : OsuPlayfield
+    {
+        protected override CursorContainer CreateCursor() => null;
+    }
+}

osu.Game.Rulesets.Osu/Edit/OsuEditRulesetContainer.cs

@@ -0,0 +1,19 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class OsuEditRulesetContainer : OsuRulesetContainer
+    {
+        public OsuEditRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset)
+            : base(ruleset, beatmap, isForCurrentRuleset)
+        {
+        }
+
+        protected override Playfield CreatePlayfield() => new OsuEditPlayfield();
+    }
+}

osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs

@@ -0,0 +1,29 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Tools;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class OsuHitObjectComposer : HitObjectComposer
+    {
+        public OsuHitObjectComposer(Ruleset ruleset)
+            : base(ruleset)
+        {
+        }
+
+        protected override RulesetContainer CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap) => new OsuEditRulesetContainer(ruleset, beatmap, true);
+
+        protected override IReadOnlyList<ICompositionTool> CompositionTools => new ICompositionTool[]
+        {
+            new HitObjectCompositionTool<HitCircle>(),
+            new HitObjectCompositionTool<Slider>(),
+            new HitObjectCompositionTool<Spinner>()
+        };
+    }
+}

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

@@ -9,6 +9,7 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Framework.Graphics.Primitives;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -165,6 +166,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         }
 
         public Drawable ProxiedLayer => initialCircle.ApproachCircle;
+
+        public override Vector2 SelectionPoint => ToScreenSpace(body.Position);
+        public override Quad SelectionQuad => body.PathDrawQuad;
     }
 
     internal interface ISliderProgress

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SliderBody.cs

@@ -14,6 +14,7 @@ using osu.Game.Configuration;
 using OpenTK;
 using OpenTK.Graphics.ES30;
 using OpenTK.Graphics;
+using osu.Framework.Graphics.Primitives;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
@@ -49,6 +50,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             }
         }
 
+        public Quad PathDrawQuad => container.ScreenSpaceDrawQuad;
+
         private int textureWidth => (int)PathWidth * 2;
 
         private readonly Slider slider;
@@ -182,4 +185,4 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             SetRange(start, end);
         }
     }
-}
+}

osu.Game.Rulesets.Osu/Objects/Slider.cs

@@ -45,6 +45,18 @@ namespace osu.Game.Rulesets.Osu.Objects
             set { Curve.Distance = value; }
         }
 
+        /// <summary>
+        /// The position of the cursor at the point of completion of this <see cref="Slider"/> if it was hit
+        /// with as few movements as possible. This is set and used by difficulty calculation.
+        /// </summary>
+        internal Vector2? LazyEndPosition;
+
+        /// <summary>
+        /// The distance travelled by the cursor upon completion of this <see cref="Slider"/> if it was hit
+        /// with as few movements as possible. This is set and used by difficulty calculation.
+        /// </summary>
+        internal float LazyTravelDistance;
+
         public List<SampleInfoList> RepeatSamples { get; set; } = new List<SampleInfoList>();
         public int RepeatCount { get; set; } = 1;
 

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

@@ -33,9 +33,9 @@ namespace osu.Game.Rulesets.Osu.OsuDifficulty
                 (h as Slider)?.Curve?.Calculate();
         }
 
-        public override double Calculate(Dictionary<string, string> categoryDifficulty = null)
+        public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
         {
-            OsuDifficultyBeatmap beatmap = new OsuDifficultyBeatmap(Beatmap.HitObjects);
+            OsuDifficultyBeatmap beatmap = new OsuDifficultyBeatmap(Beatmap.HitObjects, TimeRate);
             Skill[] skills =
             {
                 new Aim(),
@@ -67,8 +67,8 @@ namespace osu.Game.Rulesets.Osu.OsuDifficulty
 
             if (categoryDifficulty != null)
             {
-                categoryDifficulty.Add("Aim", aimRating.ToString("0.00"));
-                categoryDifficulty.Add("Speed", speedRating.ToString("0.00"));
+                categoryDifficulty.Add("Aim", aimRating);
+                categoryDifficulty.Add("Speed", speedRating);
             }
 
             return starRating;

osu.Game.Rulesets.Osu/OsuDifficulty/Preprocessing/OsuDifficultyBeatmap.cs

@@ -20,12 +20,12 @@ namespace osu.Game.Rulesets.Osu.OsuDifficulty.Preprocessing
         /// Creates an enumerator, which preprocesses a list of <see cref="OsuHitObject"/>s recieved as input, wrapping them as
         /// <see cref="OsuDifficultyHitObject"/> which contains extra data required for difficulty calculation.
         /// </summary>
-        public OsuDifficultyBeatmap(List<OsuHitObject> objects)
+        public OsuDifficultyBeatmap(List<OsuHitObject> objects, double timeRate)
         {
             // Sort OsuHitObjects by StartTime - they are not correctly ordered in some cases.
             // This should probably happen before the objects reach the difficulty calculator.
             objects.Sort((a, b) => a.StartTime.CompareTo(b.StartTime));
-            difficultyObjects = createDifficultyObjectEnumerator(objects);
+            difficultyObjects = createDifficultyObjectEnumerator(objects, timeRate);
         }
 
         /// <summary>
@@ -67,7 +67,7 @@ namespace osu.Game.Rulesets.Osu.OsuDifficulty.Preprocessing
 
         IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
-        private IEnumerator<OsuDifficultyHitObject> createDifficultyObjectEnumerator(List<OsuHitObject> objects)
+        private IEnumerator<OsuDifficultyHitObject> createDifficultyObjectEnumerator(List<OsuHitObject> objects, double timeRate)
         {
             // We will process OsuHitObjects in groups of three to form a triangle, so we can calculate an angle for each object.
             OsuHitObject[] triangle = new OsuHitObject[3];
@@ -87,7 +87,7 @@ namespace osu.Game.Rulesets.Osu.OsuDifficulty.Preprocessing
                 triangle[1] = triangle[0];
                 triangle[0] = objects[i];
 
-                yield return new OsuDifficultyHitObject(triangle);
+                yield return new OsuDifficultyHitObject(triangle, timeRate);
             }
         }
     }

osu.Game.Rulesets.Osu/OsuDifficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -2,6 +2,8 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Linq;
+using OpenTK;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.OsuDifficulty.Preprocessing
@@ -33,13 +35,17 @@ namespace osu.Game.Rulesets.Osu.OsuDifficulty.Preprocessing
 
         private const int normalized_radius = 52;
 
+        private readonly double timeRate;
+
         private readonly OsuHitObject[] t;
 
         /// <summary>
         /// Initializes the object calculating extra data required for difficulty calculation.
         /// </summary>
-        public OsuDifficultyHitObject(OsuHitObject[] triangle)
+        public OsuDifficultyHitObject(OsuHitObject[] triangle, double timeRate)
         {
+            this.timeRate = timeRate;
+
             t = triangle;
             BaseObject = t[0];
             setDistances();
@@ -57,14 +63,54 @@ namespace osu.Game.Rulesets.Osu.OsuDifficulty.Preprocessing
                 scalingFactor *= 1 + smallCircleBonus;
             }
 
-            Distance = (t[0].StackedPosition - t[1].StackedPosition).Length * scalingFactor;
+            Vector2 lastCursorPosition = t[1].StackedPosition;
+            float lastTravelDistance = 0;
+
+            var lastSlider = t[1] as Slider;
+            if (lastSlider != null)
+            {
+                computeSliderCursorPosition(lastSlider);
+                lastCursorPosition = lastSlider.LazyEndPosition ?? lastCursorPosition;
+                lastTravelDistance = lastSlider.LazyTravelDistance;
+            }
+
+            Distance = (lastTravelDistance + (BaseObject.StackedPosition - lastCursorPosition).Length) * scalingFactor;
         }
 
         private void setTimingValues()
         {
             // Every timing inverval is hard capped at the equivalent of 375 BPM streaming speed as a safety measure.
-            DeltaTime = Math.Max(40, t[0].StartTime - t[1].StartTime);
+            DeltaTime = Math.Max(40, (t[0].StartTime - t[1].StartTime) / timeRate);
             TimeUntilHit = 450; // BaseObject.PreEmpt;
         }
+
+        private void computeSliderCursorPosition(Slider slider)
+        {
+            if (slider.LazyEndPosition != null)
+                return;
+            slider.LazyEndPosition = slider.StackedPosition;
+
+            float approxFollowCircleRadius = (float)(slider.Radius * 3);
+            var computeVertex = new Action<double>(t =>
+            {
+                // ReSharper disable once PossibleInvalidOperationException (bugged in current r# version)
+                var diff = slider.PositionAt(t) - slider.LazyEndPosition.Value;
+                float dist = diff.Length;
+
+                if (dist > approxFollowCircleRadius)
+                {
+                    // The cursor would be outside the follow circle, we need to move it
+                    diff.Normalize(); // Obtain direction of diff
+                    dist -= approxFollowCircleRadius;
+                    slider.LazyEndPosition += diff * dist;
+                    slider.LazyTravelDistance += dist;
+                }
+            });
+
+            var scoringTimes = slider.Ticks.Select(t => t.StartTime).Concat(slider.RepeatPoints.Select(r => r.StartTime)).OrderBy(t => t);
+            foreach (var time in scoringTimes)
+                computeVertex(time);
+            computeVertex(slider.EndTime);
+        }
     }
 }

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -1,6 +1,7 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System.Collections.Generic;
 using System.ComponentModel;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.UI;
@@ -9,6 +10,8 @@ namespace osu.Game.Rulesets.Osu
 {
     public class OsuInputManager : RulesetInputManager<OsuAction>
     {
+        public IEnumerable<OsuAction> PressedActions => KeyBindingContainer.PressedActions;
+
         public OsuInputManager(RulesetInfo ruleset) : base(ruleset, 0, SimultaneousBindingMode.Unique)
         {
         }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -5,7 +5,6 @@ using osu.Game.Beatmaps;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.OsuDifficulty;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
@@ -14,6 +13,12 @@ using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Overlays.Settings;
 using osu.Framework.Input.Bindings;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Osu.Edit;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Osu
 {
@@ -29,21 +34,35 @@ namespace osu.Game.Rulesets.Osu
             new KeyBinding(InputKey.MouseRight, OsuAction.RightButton),
         };
 
-        public override IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap) => new[]
+        public override IEnumerable<BeatmapStatistic> GetBeatmapStatistics(WorkingBeatmap beatmap)
         {
-            new BeatmapStatistic
+            IEnumerable<HitObject> hitObjects = beatmap.Beatmap.HitObjects;
+            IEnumerable<HitObject> circles = hitObjects.Where(c => !(c is IHasEndTime));
+            IEnumerable<HitObject> sliders = hitObjects.Where(s => s is IHasCurve);
+            IEnumerable<HitObject> spinners = hitObjects.Where(s => s is IHasEndTime && !(s is IHasCurve));
+
+            return new[]
             {
-                Name = @"Circle count",
-                Content = beatmap.Beatmap.HitObjects.Count(h => h is HitCircle).ToString(),
-                Icon = FontAwesome.fa_dot_circle_o
-            },
-            new BeatmapStatistic
-            {
-                Name = @"Slider count",
-                Content = beatmap.Beatmap.HitObjects.Count(h => h is Slider).ToString(),
-                Icon = FontAwesome.fa_circle_o
-            }
-        };
+                new BeatmapStatistic
+                {
+                    Name = @"Circle Count",
+                    Content = circles.Count().ToString(),
+                    Icon = FontAwesome.fa_circle_o
+                },
+                new BeatmapStatistic
+                {
+                    Name = @"Slider Count",
+                    Content = sliders.Count().ToString(),
+                    Icon = FontAwesome.fa_circle
+                },
+                new BeatmapStatistic
+                {
+                    Name = @"Spinner Count",
+                    Content = spinners.Count().ToString(),
+                    Icon = FontAwesome.fa_circle
+                }
+            };
+        }
 
         public override IEnumerable<Mod> GetModsFor(ModType type)
         {
@@ -114,8 +133,14 @@ namespace osu.Game.Rulesets.Osu
 
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new OsuDifficultyCalculator(beatmap, mods);
 
+        public override PerformanceCalculator CreatePerformanceCalculator(Beatmap beatmap, Score score) => new OsuPerformanceCalculator(this, beatmap, score);
+
+        public override HitObjectComposer CreateHitObjectComposer() => new OsuHitObjectComposer(this);
+
         public override string Description => "osu!";
 
+        public override string ShortName => "osu";
+
         public override SettingsSubsection CreateSettings() => new OsuSettings();
 
         public override int LegacyID => 0;

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

@@ -0,0 +1,199 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Scoring
+{
+    public class OsuPerformanceCalculator : PerformanceCalculator<OsuHitObject>
+    {
+        private readonly int countHitCircles;
+        private readonly int beatmapMaxCombo;
+
+        private Mod[] mods;
+        private double realApproachRate;
+        private double accuracy;
+        private int scoreMaxCombo;
+        private int count300;
+        private int count100;
+        private int count50;
+        private int countMiss;
+
+        public OsuPerformanceCalculator(Ruleset ruleset, Beatmap beatmap, Score score)
+            : base(ruleset, beatmap, score)
+        {
+            countHitCircles = Beatmap.HitObjects.Count(h => h is HitCircle);
+
+            beatmapMaxCombo = Beatmap.HitObjects.Count;
+            beatmapMaxCombo += Beatmap.HitObjects.OfType<Slider>().Sum(s => s.RepeatCount + s.Ticks.Count());
+        }
+
+        public override double Calculate(Dictionary<string, double> categoryRatings = null)
+        {
+            mods = Score.Mods;
+            accuracy = Score.Accuracy;
+            scoreMaxCombo = Score.MaxCombo;
+            count300 = Convert.ToInt32(Score.Statistics["300"]);
+            count100 = Convert.ToInt32(Score.Statistics["100"]);
+            count50 = Convert.ToInt32(Score.Statistics["50"]);
+            countMiss = Convert.ToInt32(Score.Statistics["x"]);
+
+            // Don't count scores made with supposedly unranked mods
+            if (mods.Any(m => !m.Ranked))
+                return 0;
+
+            // Todo: In the future we should apply changes to PreEmpt/AR at an OsuHitObject/BaseDifficulty level, but this is done
+            // locally for now as doing so would modify animations and other things unexpectedly
+            // DO NOT MODIFY THIS
+            double ar = Beatmap.BeatmapInfo.BaseDifficulty.ApproachRate;
+            if (mods.Any(m => m is OsuModHardRock))
+                ar = Math.Min(10, ar * 1.4);
+            if (mods.Any(m => m is OsuModEasy))
+                ar = Math.Max(0, ar / 2);
+            double preEmpt = BeatmapDifficulty.DifficultyRange(ar, 1800, 1200, 450);
+            realApproachRate = preEmpt > 1200 ? (1800 - preEmpt) / 120 : (1200 - preEmpt) / 150 + 5;
+
+            // Custom multipliers for NoFail and SpunOut.
+            double multiplier = 1.12f; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things
+
+            if (mods.Any(m => m is OsuModNoFail))
+                multiplier *= 0.90f;
+
+            if (mods.Any(m => m is OsuModSpunOut))
+                multiplier *= 0.95f;
+
+            double aimValue = computeAimValue();
+            double speedValue = computeSpeedValue();
+            double accuracyValue = computeAccuracyValue();
+            double totalValue =
+                Math.Pow(
+                    Math.Pow(aimValue, 1.1f) +
+                    Math.Pow(speedValue, 1.1f) +
+                    Math.Pow(accuracyValue, 1.1f), 1.0f / 1.1f
+                ) * multiplier;
+
+            if (categoryRatings != null)
+            {
+                categoryRatings.Add("Aim", aimValue);
+                categoryRatings.Add("Speed", speedValue);
+                categoryRatings.Add("Accuracy", accuracyValue);
+            }
+
+            return totalValue;
+        }
+
+        private double computeAimValue()
+        {
+            double aimValue = Math.Pow(5.0f * Math.Max(1.0f, Attributes["Aim"] / 0.0675f) - 4.0f, 3.0f) / 100000.0f;
+
+            // Longer maps are worth more
+            double lengthBonus = 0.95f + 0.4f * Math.Min(1.0f, totalHits / 2000.0f) +
+                (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);
+
+            aimValue *= lengthBonus;
+
+            // Penalize misses exponentially. This mainly fixes tag4 maps and the likes until a per-hitobject solution is available
+            aimValue *= Math.Pow(0.97f, countMiss);
+
+            // Combo scaling
+            if (beatmapMaxCombo > 0)
+                aimValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8f) / Math.Pow(beatmapMaxCombo, 0.8f), 1.0f);
+
+            double approachRateFactor = 1.0f;
+            if (realApproachRate > 10.33f)
+                approachRateFactor += 0.45f * (realApproachRate - 10.33f);
+            else if (realApproachRate < 8.0f)
+            {
+                // HD is worth more with lower ar!
+                if (mods.Any(h => h is OsuModHidden))
+                    approachRateFactor += 0.02f * (8.0f - realApproachRate);
+                else
+                    approachRateFactor += 0.01f * (8.0f - realApproachRate);
+            }
+
+            aimValue *= approachRateFactor;
+
+            if (mods.Any(h => h is OsuModHidden))
+                aimValue *= 1.18f;
+
+            if (mods.Any(h => h is OsuModFlashlight))
+            {
+                // Apply length bonus again if flashlight is on simply because it becomes a lot harder on longer maps.
+                aimValue *= 1.45f * lengthBonus;
+            }
+
+            // Scale the aim value with accuracy _slightly_
+            aimValue *= 0.5f + accuracy / 2.0f;
+            // It is important to also consider accuracy difficulty when doing that
+            aimValue *= 0.98f + Math.Pow(Beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty, 2) / 2500;
+
+            return aimValue;
+        }
+
+        private double computeSpeedValue()
+        {
+            double speedValue = Math.Pow(5.0f * Math.Max(1.0f, Attributes["Speed"] / 0.0675f) - 4.0f, 3.0f) / 100000.0f;
+
+            // Longer maps are worth more
+            speedValue *= 0.95f + 0.4f * Math.Min(1.0f, totalHits / 2000.0f) +
+                (totalHits > 2000 ? Math.Log10(totalHits / 2000.0f) * 0.5f : 0.0f);
+
+            // Penalize misses exponentially. This mainly fixes tag4 maps and the likes until a per-hitobject solution is available
+            speedValue *= Math.Pow(0.97f, countMiss);
+
+            // Combo scaling
+            if (beatmapMaxCombo > 0)
+                speedValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8f) / Math.Pow(beatmapMaxCombo, 0.8f), 1.0f);
+
+            // Scale the speed value with accuracy _slightly_
+            speedValue *= 0.5f + accuracy / 2.0f;
+            // It is important to also consider accuracy difficulty when doing that
+            speedValue *= 0.98f + Math.Pow(Beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty, 2) / 2500;
+
+            return speedValue;
+        }
+
+        private double computeAccuracyValue()
+        {
+            // This percentage only considers HitCircles of any value - in this part of the calculation we focus on hitting the timing hit window
+            double betterAccuracyPercentage;
+            int amountHitObjectsWithAccuracy = countHitCircles;
+
+            if (amountHitObjectsWithAccuracy > 0)
+                betterAccuracyPercentage = ((count300 - (totalHits - amountHitObjectsWithAccuracy)) * 6 + count100 * 2 + count50) / (amountHitObjectsWithAccuracy * 6);
+            else
+                betterAccuracyPercentage = 0;
+
+            // It is possible to reach a negative accuracy with this formula. Cap it at zero - zero points
+            if (betterAccuracyPercentage < 0)
+                betterAccuracyPercentage = 0;
+
+            // Lots of arbitrary values from testing.
+            // Considering to use derivation from perfect accuracy in a probabilistic manner - assume normal distribution
+            double accuracyValue = Math.Pow(1.52163f, Beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty) * Math.Pow(betterAccuracyPercentage, 24) * 2.83f;
+
+            // Bonus for many hitcircles - it's harder to keep good accuracy up for longer
+            accuracyValue *= Math.Min(1.15f, Math.Pow(amountHitObjectsWithAccuracy / 1000.0f, 0.3f));
+
+            if (mods.Any(m => m is OsuModHidden))
+                accuracyValue *= 1.02f;
+            if (mods.Any(m => m is OsuModFlashlight))
+                accuracyValue *= 1.02f;
+
+            return accuracyValue;
+        }
+
+        private double totalHits => count300 + count100 + count50 + countMiss;
+        private double totalSuccessfulHits => count300 + count100 + count50;
+
+        protected override BeatmapConverter<OsuHitObject> CreateBeatmapConverter() => new OsuBeatmapConverter();
+    }
+}

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

@@ -17,7 +17,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 {
     [TestFixture]
     [Ignore("getting CI working")]
-    internal class TestCaseHitObjects : OsuTestCase
+    public class TestCaseHitObjects : OsuTestCase
     {
         private FramedClock framedClock;
 

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

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

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

@@ -20,8 +20,6 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 {
     internal class CursorTrail : Drawable
     {
-        public override bool HandleInput => true;
-
         private int currentIndex;
 
         private Shader shader;

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

@@ -13,6 +13,7 @@ using System.Linq;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.UI.Cursor;
+using osu.Framework.Graphics.Cursor;
 
 namespace osu.Game.Rulesets.Osu.UI
 {
@@ -30,6 +31,9 @@ namespace osu.Game.Rulesets.Osu.UI
         {
             get
             {
+                if (Parent == null)
+                    return Vector2.Zero;
+
                 var parentSize = Parent.DrawSize;
                 var aspectSize = parentSize.X * 0.75f < parentSize.Y ? new Vector2(parentSize.X, parentSize.X * 0.75f) : new Vector2(parentSize.Y * 4f / 3f, parentSize.Y);
 
@@ -65,7 +69,10 @@ namespace osu.Game.Rulesets.Osu.UI
         protected override void LoadComplete()
         {
             base.LoadComplete();
-            AddInternal(new GameplayCursor());
+
+            var cursor = CreateCursor();
+            if (cursor != null)
+                AddInternal(cursor);
         }
 
         public override void Add(DrawableHitObject h)
@@ -102,5 +109,7 @@ namespace osu.Game.Rulesets.Osu.UI
 
             judgementLayer.Add(explosion);
         }
+
+        protected virtual CursorContainer CreateCursor() => new GameplayCursor();
     }
 }

osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <Import Project="..\osu.Game.props" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -22,7 +22,6 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
-    <LangVersion>6</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -49,6 +48,9 @@
   <ItemGroup>
     <Compile Include="Beatmaps\OsuBeatmapConverter.cs" />
     <Compile Include="Beatmaps\OsuBeatmapProcessor.cs" />
+    <Compile Include="Edit\OsuEditPlayfield.cs" />
+    <Compile Include="Edit\OsuEditRulesetContainer.cs" />
+    <Compile Include="Edit\OsuHitObjectComposer.cs" />
     <Compile Include="Objects\Drawables\DrawableOsuHitObject.cs" />
     <Compile Include="Objects\Drawables\Connections\ConnectionRenderer.cs" />
     <Compile Include="Objects\Drawables\Connections\FollowPointRenderer.cs" />
@@ -85,9 +87,11 @@
     <Compile Include="OsuInputManager.cs" />
     <Compile Include="Replays\OsuReplayInputHandler.cs" />
     <Compile Include="Tests\TestCaseHitObjects.cs" />
+    <Compile Include="Tests\TestCasePerformancePoints.cs" />
     <Compile Include="UI\Cursor\CursorTrail.cs" />
     <Compile Include="UI\Cursor\GameplayCursor.cs" />
     <Compile Include="UI\OsuSettings.cs" />
+    <Compile Include="Scoring\OsuPerformanceCalculator.cs" />
     <Compile Include="Scoring\OsuScoreProcessor.cs" />
     <Compile Include="UI\OsuRulesetContainer.cs" />
     <Compile Include="UI\OsuPlayfield.cs" />
@@ -103,9 +107,6 @@
     <Compile Include="Replays\OsuAutoGeneratorBase.cs" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="..\osu.licenseheader">
-      <Link>osu.licenseheader</Link>
-    </None>
     <None Include="app.config" />
     <None Include="OpenTK.dll.config" />
     <None Include="packages.config" />
@@ -122,7 +123,9 @@
       <Private>True</Private>
     </ProjectReference>
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.

osu.Game.Rulesets.Taiko/TaikoDifficultyCalculator.cs

@@ -5,7 +5,6 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Taiko.Beatmaps;
 using osu.Game.Rulesets.Taiko.Objects;
 using System.Collections.Generic;
-using System.Globalization;
 using System;
 
 namespace osu.Game.Rulesets.Taiko
@@ -36,7 +35,7 @@ namespace osu.Game.Rulesets.Taiko
         {
         }
 
-        public override double Calculate(Dictionary<string, string> categoryDifficulty = null)
+        public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
         {
             // Fill our custom DifficultyHitObject class, that carries additional information
             difficultyHitObjects.Clear();
@@ -53,8 +52,8 @@ namespace osu.Game.Rulesets.Taiko
 
             if (categoryDifficulty != null)
             {
-                categoryDifficulty.Add("Strain", starRating.ToString("0.00", CultureInfo.InvariantCulture));
-                categoryDifficulty.Add("Hit window 300", (35 /*HitObjectManager.HitWindow300*/ / TimeRate).ToString("0.00", CultureInfo.InvariantCulture));
+                categoryDifficulty.Add("Strain", starRating);
+                categoryDifficulty.Add("Hit window 300", 35 /*HitObjectManager.HitWindow300*/ / TimeRate);
             }
 
             return starRating;

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -95,6 +95,8 @@ namespace osu.Game.Rulesets.Taiko
 
         public override string Description => "osu!taiko";
 
+        public override string ShortName => "taiko";
+
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_taiko_o };
 
         public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new TaikoDifficultyCalculator(beatmap);

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

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

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

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
 {
     [TestFixture]
     [Ignore("getting CI working")]
-    internal class TestCaseTaikoPlayfield : OsuTestCase
+    public class TestCaseTaikoPlayfield : OsuTestCase
     {
         private const double default_duration = 1000;
         private const float scroll_time = 1000;

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

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <Import Project="..\osu.Game.props" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
@@ -21,7 +21,6 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
-    <LangVersion>6</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -83,6 +82,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Scoring\TaikoScoreProcessor.cs" />
     <Compile Include="TaikoInputManager.cs" />
+    <Compile Include="Tests\TestCasePerformancePoints.cs" />
     <Compile Include="Tests\TestCaseTaikoPlayfield.cs" />
     <Compile Include="UI\HitTarget.cs" />
     <Compile Include="UI\InputDrum.cs" />
@@ -95,9 +95,6 @@
     <Compile Include="Mods\TaikoMod.cs" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="..\osu.licenseheader">
-      <Link>osu.licenseheader</Link>
-    </None>
     <None Include="app.config" />
     <None Include="OpenTK.dll.config" />
     <None Include="packages.config" />
@@ -114,6 +111,9 @@
       <Private>True</Private>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
        Other similar extension points exist, see Microsoft.Common.targets.

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/TestCaseBeatSyncedContainer.cs

@@ -17,7 +17,7 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseBeatSyncedContainer : OsuTestCase
+    public class TestCaseBeatSyncedContainer : OsuTestCase
     {
         private readonly MusicController mc;
 

osu.Game.Tests/Visual/TestCaseBeatmapCarousel.cs

@@ -0,0 +1,342 @@
+// 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 System.Linq;
+using System.Text;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Carousel;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseBeatmapCarousel : OsuTestCase
+    {
+        private TestBeatmapCarousel carousel;
+
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(CarouselItem),
+            typeof(CarouselGroup),
+            typeof(CarouselGroupEagerSelect),
+            typeof(CarouselBeatmap),
+            typeof(CarouselBeatmapSet),
+
+            typeof(DrawableCarouselItem),
+            typeof(CarouselItemState),
+
+            typeof(DrawableCarouselBeatmap),
+            typeof(DrawableCarouselBeatmapSet),
+        };
+
+
+        private readonly Stack<BeatmapSetInfo> selectedSets = new Stack<BeatmapSetInfo>();
+
+        private BeatmapInfo currentSelection;
+
+        private const int set_count = 5;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Add(carousel = new TestBeatmapCarousel
+            {
+                RelativeSizeAxes = Axes.Both,
+            });
+
+            List<BeatmapSetInfo> beatmapSets = new List<BeatmapSetInfo>();
+
+            for (int i = 1; i <= set_count; i++)
+                beatmapSets.Add(createTestBeatmapSet(i));
+
+            carousel.SelectionChanged = s => currentSelection = s;
+
+            AddStep("Load Beatmaps", () => { carousel.BeatmapSets = beatmapSets; });
+
+            AddUntilStep(() => carousel.BeatmapSets.Any(), "Wait for load");
+
+            testTraversal();
+            testFiltering();
+            testRandom();
+            testAddRemove();
+            testSorting();
+
+            testRemoveAll();
+        }
+
+        private void ensureRandomFetchSuccess() =>
+            AddAssert("ensure prev random fetch worked", () => selectedSets.Peek() == carousel.SelectedBeatmapSet);
+
+        private void checkSelected(int set, int? diff = null) =>
+            AddAssert($"selected is set{set}{(diff.HasValue ? $" diff{diff.Value}" : "")}", () =>
+            {
+                if (diff != null)
+                    return carousel.SelectedBeatmap == carousel.BeatmapSets.Skip(set - 1).First().Beatmaps.Skip(diff.Value - 1).First();
+
+                return carousel.BeatmapSets.Skip(set - 1).First().Beatmaps.Contains(carousel.SelectedBeatmap);
+            });
+
+        private void setSelected(int set, int diff) =>
+            AddStep($"select set{set} diff{diff}", () =>
+                carousel.SelectBeatmap(carousel.BeatmapSets.Skip(set - 1).First().Beatmaps.Skip(diff - 1).First()));
+
+        private void advanceSelection(bool diff, int direction = 1, int count = 1)
+        {
+            if (count == 1)
+                AddStep($"select {(direction > 0 ? "next" : "prev")} {(diff ? "diff" : "set")}", () =>
+                    carousel.SelectNext(direction, !diff));
+            else
+            {
+                AddRepeatStep($"select {(direction > 0 ? "next" : "prev")} {(diff ? "diff" : "set")}", () =>
+                    carousel.SelectNext(direction, !diff), count);
+            }
+        }
+
+        private void checkVisibleItemCount(bool diff, int count) =>
+            AddAssert($"{count} {(diff ? "diffs" : "sets")} visible", () =>
+                carousel.Items.Count(s => (diff ? s.Item is CarouselBeatmap : s.Item is CarouselBeatmapSet) && s.Item.Visible) == count);
+
+        private void nextRandom() =>
+            AddStep("select random next", () =>
+            {
+                carousel.RandomAlgorithm.Value = RandomSelectAlgorithm.RandomPermutation;
+
+                if (!selectedSets.Any() && carousel.SelectedBeatmap != null)
+                    selectedSets.Push(carousel.SelectedBeatmapSet);
+
+                carousel.SelectNextRandom();
+                selectedSets.Push(carousel.SelectedBeatmapSet);
+            });
+
+        private void ensureRandomDidntRepeat() =>
+            AddAssert("ensure no repeats", () => selectedSets.Distinct().Count() == selectedSets.Count);
+
+        private void prevRandom() => AddStep("select random last", () =>
+        {
+            carousel.SelectPreviousRandom();
+            selectedSets.Pop();
+        });
+
+        /// <summary>
+        /// Test keyboard traversal
+        /// </summary>
+        private void testTraversal()
+        {
+            advanceSelection(direction: 1, diff: false);
+            checkSelected(1, 1);
+
+            advanceSelection(direction: 1, diff: true);
+            checkSelected(1, 2);
+
+            advanceSelection(direction: -1, diff: false);
+            checkSelected(set_count, 1);
+
+            advanceSelection(direction: -1, diff: true);
+            checkSelected(set_count - 1, 3);
+
+            advanceSelection(diff: false);
+            advanceSelection(diff: false);
+            checkSelected(1, 2);
+
+            advanceSelection(direction: -1, diff: true);
+            advanceSelection(direction: -1, diff: true);
+            checkSelected(set_count, 3);
+        }
+
+        /// <summary>
+        /// Test filtering
+        /// </summary>
+        private void testFiltering()
+        {
+            // basic filtering
+
+            setSelected(1, 1);
+
+            AddStep("Filter", () => carousel.Filter(new FilterCriteria { SearchText = "set #3!" }, false));
+            checkVisibleItemCount(diff: false, count: 1);
+            checkVisibleItemCount(diff: true, count: 3);
+            checkSelected(3, 1);
+
+            advanceSelection(diff: true, count: 4);
+            checkSelected(3, 2);
+
+            AddStep("Un-filter (debounce)", () => carousel.Filter(new FilterCriteria()));
+            AddUntilStep(() => !carousel.PendingFilterTask, "Wait for debounce");
+            checkVisibleItemCount(diff: false, count: set_count);
+            checkVisibleItemCount(diff: true, count: 3);
+
+            // test filtering some difficulties (and keeping current beatmap set selected).
+
+            setSelected(1, 2);
+            AddStep("Filter some difficulties", () => carousel.Filter(new FilterCriteria { SearchText = "Normal" }, false));
+            checkSelected(1, 1);
+
+            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
+            checkSelected(1, 1);
+
+            AddStep("Filter all", () => carousel.Filter(new FilterCriteria { SearchText = "Dingo" }, false));
+
+            checkVisibleItemCount(false, 0);
+            checkVisibleItemCount(true, 0);
+            AddAssert("Selection is null", () => currentSelection == null);
+
+            AddStep("Un-filter", () => carousel.Filter(new FilterCriteria(), false));
+
+            AddAssert("Selection is non-null", () => currentSelection != null);
+        }
+
+        /// <summary>
+        /// Test random non-repeating algorithm
+        /// </summary>
+        private void testRandom()
+        {
+            setSelected(1, 1);
+
+            nextRandom();
+            ensureRandomDidntRepeat();
+            nextRandom();
+            ensureRandomDidntRepeat();
+            nextRandom();
+            ensureRandomDidntRepeat();
+
+            prevRandom();
+            ensureRandomFetchSuccess();
+            prevRandom();
+            ensureRandomFetchSuccess();
+
+            nextRandom();
+            ensureRandomDidntRepeat();
+            nextRandom();
+            ensureRandomDidntRepeat();
+
+            nextRandom();
+            AddAssert("ensure repeat", () => selectedSets.Contains(carousel.SelectedBeatmapSet));
+        }
+
+        /// <summary>
+        /// Test adding and removing beatmap sets
+        /// </summary>
+        private void testAddRemove()
+        {
+            AddStep("Add new set", () => carousel.UpdateBeatmapSet(createTestBeatmapSet(set_count + 1)));
+            AddStep("Add new set", () => carousel.UpdateBeatmapSet(createTestBeatmapSet(set_count + 2)));
+
+            checkVisibleItemCount(false, set_count + 2);
+
+            AddStep("Remove set", () => carousel.RemoveBeatmapSet(createTestBeatmapSet(set_count + 2)));
+
+            checkVisibleItemCount(false, set_count + 1);
+
+            setSelected(set_count + 1, 1);
+
+            AddStep("Remove set", () => carousel.RemoveBeatmapSet(createTestBeatmapSet(set_count + 1)));
+
+            checkVisibleItemCount(false, set_count);
+
+            checkSelected(set_count);
+        }
+
+        /// <summary>
+        /// Test sorting
+        /// </summary>
+        private void testSorting()
+        {
+            AddStep("Sort by author", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Author }, false));
+            AddAssert("Check zzzzz is at bottom", () => carousel.BeatmapSets.Last().Metadata.AuthorString == "zzzzz");
+            AddStep("Sort by artist", () => carousel.Filter(new FilterCriteria { Sort = SortMode.Artist }, false));
+            AddAssert($"Check #{set_count} is at bottom", () => carousel.BeatmapSets.Last().Metadata.Title.EndsWith($"#{set_count}!"));
+        }
+
+        private void testRemoveAll()
+        {
+            setSelected(2, 1);
+            AddAssert("Selection is non-null", () => currentSelection != null);
+
+            AddStep("Remove selected", () => carousel.RemoveBeatmapSet(carousel.SelectedBeatmapSet));
+            checkSelected(2);
+
+            AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
+            AddStep("Remove first", () => carousel.RemoveBeatmapSet(carousel.BeatmapSets.First()));
+            checkSelected(1);
+
+            AddUntilStep(() =>
+            {
+                if (!carousel.BeatmapSets.Any()) return true;
+
+                carousel.RemoveBeatmapSet(carousel.BeatmapSets.Last());
+                return false;
+            }, "Remove all");
+
+            AddAssert("Selection is null", () => currentSelection == null);
+        }
+
+
+        private BeatmapSetInfo createTestBeatmapSet(int i)
+        {
+            return new BeatmapSetInfo
+            {
+                ID = i,
+                OnlineBeatmapSetID = i,
+                Hash = new MemoryStream(Encoding.UTF8.GetBytes(Guid.NewGuid().ToString())).ComputeMD5Hash(),
+                Metadata = new BeatmapMetadata
+                {
+                    OnlineBeatmapSetID = i,
+                    // Create random metadata, then we can check if sorting works based on these
+                    Artist = $"peppy{i.ToString().PadLeft(6, '0')}",
+                    Title = $"test set #{i}!",
+                    AuthorString = string.Concat(Enumerable.Repeat((char)('z' - Math.Min(25, i - 1)), 5))
+                },
+                Beatmaps = new List<BeatmapInfo>(new[]
+                {
+                    new BeatmapInfo
+                    {
+                        OnlineBeatmapID = i * 10,
+                        Path = "normal.osu",
+                        Version = "Normal",
+                        StarDifficulty = 2,
+                        BaseDifficulty = new BeatmapDifficulty
+                        {
+                            OverallDifficulty = 3.5f,
+                        }
+                    },
+                    new BeatmapInfo
+                    {
+                        OnlineBeatmapID = i * 10 + 1,
+                        Path = "hard.osu",
+                        Version = "Hard",
+                        StarDifficulty = 5,
+                        BaseDifficulty = new BeatmapDifficulty
+                        {
+                            OverallDifficulty = 5,
+                        }
+                    },
+                    new BeatmapInfo
+                    {
+                        OnlineBeatmapID = i * 10 + 2,
+                        Path = "insane.osu",
+                        Version = "Insane",
+                        StarDifficulty = 6,
+                        BaseDifficulty = new BeatmapDifficulty
+                        {
+                            OverallDifficulty = 7,
+                        }
+                    },
+                }),
+            };
+        }
+
+        private class TestBeatmapCarousel : BeatmapCarousel
+        {
+            public new List<DrawableCarouselItem> Items => base.Items;
+
+            public bool PendingFilterTask => FilterTask != null;
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseBeatmapDetailArea.cs

@@ -10,7 +10,7 @@ namespace osu.Game.Tests.Visual
 {
     [TestFixture]
     [System.ComponentModel.Description("PlaySongSelect leaderboard/details area")]
-    internal class TestCaseBeatmapDetailArea : OsuTestCase
+    public class TestCaseBeatmapDetailArea : OsuTestCase
     {
         public TestCaseBeatmapDetailArea()
         {

osu.Game.Tests/Visual/TestCaseBeatmapDetails.cs

@@ -10,7 +10,7 @@ using osu.Game.Screens.Select;
 namespace osu.Game.Tests.Visual
 {
     [Description("PlaySongSelect beatmap details")]
-    internal class TestCaseBeatmapDetails : OsuTestCase
+    public class TestCaseBeatmapDetails : OsuTestCase
     {
         public TestCaseBeatmapDetails()
         {

osu.Game.Tests/Visual/TestCaseBeatmapInfoWedge.cs

@@ -0,0 +1,69 @@
+// 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 OpenTK;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Screens.Select;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseBeatmapInfoWedge : OsuTestCase
+    {
+        private BeatmapManager beatmaps;
+        private readonly Random random;
+        private readonly BeatmapInfoWedge infoWedge;
+        private readonly Bindable<WorkingBeatmap> beatmap = new Bindable<WorkingBeatmap>();
+
+        public TestCaseBeatmapInfoWedge()
+        {
+            random = new Random(0123);
+
+            Add(infoWedge = new BeatmapInfoWedge
+            {
+                Size = new Vector2(0.5f, 245),
+                RelativeSizeAxes = Axes.X,
+                Margin = new MarginPadding
+                {
+                    Top = 20,
+                },
+            });
+
+            AddStep("show", () =>
+            {
+                Content.FadeInFromZero(250);
+                infoWedge.State = Visibility.Visible;
+                infoWedge.UpdateBeatmap(beatmap);
+            });
+            AddStep("hide", () =>
+            {
+                infoWedge.State = Visibility.Hidden;
+                Content.FadeOut(100);
+            });
+            AddStep("random beatmap", randomBeatmap);
+            AddStep("null beatmap", () => infoWedge.UpdateBeatmap(beatmap.Default));
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuGameBase game, BeatmapManager beatmaps)
+        {
+            this.beatmaps = beatmaps;
+            beatmap.BindTo(game.Beatmap);
+        }
+
+        private void randomBeatmap()
+        {
+            var sets = beatmaps.GetAllUsableBeatmapSets();
+            if (sets.Count == 0)
+                return;
+
+            var b = sets[random.Next(0, sets.Count)].Beatmaps[0];
+            beatmap.Value = beatmaps.GetWorkingBeatmap(b);
+            infoWedge.UpdateBeatmap(beatmap);
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseBeatmapOptionsOverlay.cs

@@ -10,7 +10,7 @@ using OpenTK.Input;
 namespace osu.Game.Tests.Visual
 {
     [Description("bottom beatmap details")]
-    internal class TestCaseBeatmapOptionsOverlay : OsuTestCase
+    public class TestCaseBeatmapOptionsOverlay : OsuTestCase
     {
         public TestCaseBeatmapOptionsOverlay()
         {

osu.Game.Tests/Visual/TestCaseBeatmapSetOverlay.cs

@@ -12,7 +12,7 @@ using osu.Game.Users;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseBeatmapSetOverlay : OsuTestCase
+    public class TestCaseBeatmapSetOverlay : OsuTestCase
     {
         private readonly BeatmapSetOverlay overlay;
 

osu.Game.Tests/Visual/TestCaseBreadcrumbs.cs

@@ -6,7 +6,7 @@ using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseBreadcrumbs : OsuTestCase
+    public class TestCaseBreadcrumbs : OsuTestCase
     {
         public TestCaseBreadcrumbs()
         {

osu.Game.Tests/Visual/TestCaseBreakOverlay.cs

@@ -8,7 +8,7 @@ using System.Collections.Generic;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseBreakOverlay : OsuTestCase
+    public class TestCaseBreakOverlay : OsuTestCase
     {
         private readonly BreakOverlay breakOverlay;
 

osu.Game.Tests/Visual/TestCaseButtonSystem.cs

@@ -9,7 +9,7 @@ using OpenTK.Graphics;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseButtonSystem : OsuTestCase
+    public class TestCaseButtonSystem : OsuTestCase
     {
         public TestCaseButtonSystem()
         {

osu.Game.Tests/Visual/TestCaseChatDisplay.cs

@@ -8,7 +8,7 @@ using osu.Game.Overlays;
 namespace osu.Game.Tests.Visual
 {
     [Description("Testing chat api and overlay")]
-    internal class TestCaseChatDisplay : OsuTestCase
+    public class TestCaseChatDisplay : OsuTestCase
     {
         public TestCaseChatDisplay()
         {

osu.Game.Tests/Visual/TestCaseContextMenu.cs

@@ -13,7 +13,7 @@ using osu.Game.Graphics.Cursor;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseContextMenu : OsuTestCase
+    public class TestCaseContextMenu : OsuTestCase
     {
         private const int start_time = 0;
         private const int duration = 1000;

osu.Game.Tests/Visual/TestCaseDialogOverlay.cs

@@ -7,7 +7,7 @@ using osu.Game.Overlays.Dialog;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseDialogOverlay : OsuTestCase
+    public class TestCaseDialogOverlay : OsuTestCase
     {
         public TestCaseDialogOverlay()
         {

osu.Game.Tests/Visual/TestCaseDrawableRoom.cs

@@ -12,7 +12,7 @@ using osu.Game.Users;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseDrawableRoom : OsuTestCase
+    public class TestCaseDrawableRoom : OsuTestCase
     {
         private RulesetStore rulesets;
 

osu.Game.Tests/Visual/TestCaseDrawings.cs

@@ -9,7 +9,7 @@ using osu.Game.Screens.Tournament.Teams;
 namespace osu.Game.Tests.Visual
 {
     [Description("for tournament use")]
-    internal class TestCaseDrawings : OsuTestCase
+    public class TestCaseDrawings : OsuTestCase
     {
         public TestCaseDrawings()
         {

osu.Game.Tests/Visual/TestCaseEditorCompose.cs

@@ -0,0 +1,46 @@
+// 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 osu.Framework.Allocation;
+using osu.Game.Beatmaps;
+using osu.Game.Screens.Edit.Screens.Compose;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseEditorCompose : OsuTestCase
+    {
+        private readonly Random random;
+        private readonly Compose compose;
+
+        public TestCaseEditorCompose()
+        {
+            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)
+        {
+            this.osuGame = osuGame;
+            this.beatmaps = beatmaps;
+
+            compose.Beatmap.BindTo(osuGame.Beatmap);
+        }
+
+        private void nextBeatmap()
+        {
+            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/TestCaseEditorComposeRadioButtons.cs

@@ -0,0 +1,41 @@
+// 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 osu.Framework.Graphics;
+using osu.Game.Screens.Edit.Screens.Compose.RadioButtons;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseEditorComposeRadioButtons : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(DrawableRadioButton) };
+
+        public TestCaseEditorComposeRadioButtons()
+        {
+            RadioButtonCollection collection;
+            Add(collection = new RadioButtonCollection
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Width = 150,
+                Items = new[]
+                {
+                    new RadioButton("Item 1", () => { }),
+                    new RadioButton("Item 2", () => { }),
+                    new RadioButton("Item 3", () => { }),
+                    new RadioButton("Item 4", () => { }),
+                    new RadioButton("Item 5", () => { })
+                }
+            });
+
+            for (int i = 0; i < collection.Items.Count; i++)
+            {
+                int l = i;
+                AddStep($"Select item {l + 1}", () => collection.Items[l].Select());
+                AddStep($"Deselect item {l + 1}", () => collection.Items[l].Deselect());
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseEditorSelectionLayer.cs

@@ -0,0 +1,54 @@
+// 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 OpenTK;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Timing;
+using osu.Game.Rulesets.Edit.Layers.Selection;
+using osu.Game.Rulesets.Osu.Edit;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseEditorSelectionLayer : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(SelectionLayer) };
+
+        public TestCaseEditorSelectionLayer()
+        {
+            var playfield = new OsuEditPlayfield
+            {
+                new DrawableHitCircle(new HitCircle { Position = new Vector2(256, 192), Scale = 0.5f }),
+                new DrawableHitCircle(new HitCircle { Position = new Vector2(344, 148), Scale = 0.5f }),
+                new DrawableSlider(new Slider
+                {
+                    ControlPoints = new List<Vector2>
+                    {
+                        new Vector2(128, 256),
+                        new Vector2(344, 256),
+                    },
+                    Distance = 400,
+                    Position = new Vector2(128, 256),
+                    Velocity = 1,
+                    TickDistance = 100,
+                    Scale = 0.5f
+                })
+            };
+
+            Children = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Clock = new FramedClock(new StopwatchClock()),
+                    Child = playfield
+                },
+                new SelectionLayer(playfield)
+            };
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseEditorSummaryTimeline.cs

@@ -14,7 +14,7 @@ using osu.Framework.Configuration;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseEditorSummaryTimeline : OsuTestCase
+    public class TestCaseEditorSummaryTimeline : OsuTestCase
     {
         private const int length = 60000;
         private readonly Random random;

osu.Game.Tests/Visual/TestCaseGamefield.cs

@@ -5,7 +5,7 @@ using osu.Game.Beatmaps.ControlPoints;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseGamefield : OsuTestCase
+    public class TestCaseGamefield : OsuTestCase
     {
         protected override void LoadComplete()
         {

osu.Game.Tests/Visual/TestCaseGameplayMenuOverlay.cs

@@ -0,0 +1,258 @@
+// 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.ComponentModel;
+using System.Linq;
+using OpenTK.Input;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
+using osu.Framework.Logging;
+using osu.Game.Screens.Play;
+
+namespace osu.Game.Tests.Visual
+{
+    [Description("player pause/fail screens")]
+    public class TestCaseGameplayMenuOverlay : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(FailOverlay), typeof(PauseContainer) };
+
+        private FailOverlay failOverlay;
+        private PauseContainer.PauseOverlay pauseOverlay;
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            Add(pauseOverlay = new PauseContainer.PauseOverlay
+            {
+                OnResume = () => Logger.Log(@"Resume"),
+                OnRetry = () => Logger.Log(@"Retry"),
+                OnQuit = () => Logger.Log(@"Quit"),
+            });
+
+            Add(failOverlay = new FailOverlay
+            {
+                OnRetry = () => Logger.Log(@"Retry"),
+                OnQuit = () => Logger.Log(@"Quit"),
+            });
+
+            var retryCount = 0;
+
+            AddStep("Add retry", () =>
+            {
+                retryCount++;
+                pauseOverlay.Retries = failOverlay.Retries = retryCount;
+            });
+
+            AddToggleStep("Toggle pause overlay", t => pauseOverlay.ToggleVisibility());
+            AddToggleStep("Toggle fail overlay", t => failOverlay.ToggleVisibility());
+
+            testHideResets();
+
+            testEnterWithoutSelection();
+            testKeyUpFromInitial();
+            testKeyDownFromInitial();
+            testKeyUpWrapping();
+            testKeyDownWrapping();
+
+            testMouseSelectionAfterKeySelection();
+            testKeySelectionAfterMouseSelection();
+
+            testMouseDeselectionResets();
+
+            testClickSelection();
+            testEnterKeySelection();
+        }
+
+        /// <summary>
+        /// Test that hiding the overlay after hovering a button will reset the overlay to the initial state with no buttons selected.
+        /// </summary>
+        private void testHideResets()
+        {
+            AddStep("Show overlay", () => failOverlay.Show());
+
+            AddStep("Hover first button", () => failOverlay.Buttons.First().TriggerOnHover(null));
+            AddStep("Hide overlay", () => failOverlay.Hide());
+
+            AddAssert("Overlay state is reset", () => !failOverlay.Buttons.Any(b => b.Selected));
+        }
+
+        /// <summary>
+        /// Tests that pressing enter after an overlay shows doesn't trigger an event because a selection hasn't occurred.
+        /// </summary>
+        private void testEnterWithoutSelection()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            AddStep("Press enter", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Enter }));
+            AddAssert("Overlay still open", () => pauseOverlay.State == Visibility.Visible);
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that pressing the up arrow from the initial state selects the last button.
+        /// </summary>
+        private void testKeyUpFromInitial()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            AddStep("Up arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddAssert("Last button selected", () => pauseOverlay.Buttons.Last().Selected);
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that pressing the down arrow from the initial state selects the first button.
+        /// </summary>
+        private void testKeyDownFromInitial()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            AddStep("Down arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected);
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that pressing the up arrow repeatedly causes the selected button to wrap correctly.
+        /// </summary>
+        private void testKeyUpWrapping()
+        {
+            AddStep("Show overlay", () => failOverlay.Show());
+
+            AddStep("Up arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
+            AddStep("Up arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
+            AddStep("Up arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
+
+            AddStep("Hide overlay", () => failOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that pressing the down arrow repeatedly causes the selected button to wrap correctly.
+        /// </summary>
+        private void testKeyDownWrapping()
+        {
+            AddStep("Show overlay", () => failOverlay.Show());
+
+            AddStep("Down arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
+            AddStep("Down arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
+            AddStep("Down arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
+
+            AddStep("Hide overlay", () => failOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that hovering a button that was previously selected with the keyboard correctly selects the new button and deselects the previous button.
+        /// </summary>
+        private void testMouseSelectionAfterKeySelection()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            var secondButton = pauseOverlay.Buttons.Skip(1).First();
+
+            AddStep("Down arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddStep("Hover second button", () => secondButton.TriggerOnHover(null));
+            AddAssert("First button not selected", () => !pauseOverlay.Buttons.First().Selected);
+            AddAssert("Second button selected", () => secondButton.Selected);
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that pressing a key after selecting a button with a hover event correctly selects a new button and deselects the previous button.
+        /// </summary>
+        private void testKeySelectionAfterMouseSelection()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            var secondButton = pauseOverlay.Buttons.Skip(1).First();
+
+            AddStep("Hover second button", () => secondButton.TriggerOnHover(null));
+            AddStep("Up arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddAssert("Second button not selected", () => !secondButton.Selected);
+            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected);
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that deselecting with the mouse by losing hover will reset the overlay to the initial state.
+        /// </summary>
+        private void testMouseDeselectionResets()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            var secondButton = pauseOverlay.Buttons.Skip(1).First();
+
+            AddStep("Hover second button", () => secondButton.TriggerOnHover(null));
+            AddStep("Unhover second button", () => secondButton.TriggerOnHoverLost(null));
+            AddStep("Down arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected); // Initial state condition
+
+            AddStep("Hide overlay", () => pauseOverlay.Hide());
+        }
+
+        /// <summary>
+        /// Tests that clicking on a button correctly causes a click event for that button.
+        /// </summary>
+        private void testClickSelection()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            var retryButton = pauseOverlay.Buttons.Skip(1).First();
+
+            bool triggered = false;
+            AddStep("Click retry button", () =>
+            {
+                var lastAction = pauseOverlay.OnRetry;
+                pauseOverlay.OnRetry = () => triggered = true;
+
+                retryButton.TriggerOnClick();
+                pauseOverlay.OnRetry = lastAction;
+            });
+
+            AddAssert("Action was triggered", () => triggered);
+            AddAssert("Overlay is closed", () => pauseOverlay.State == Visibility.Hidden);
+        }
+
+        /// <summary>
+        /// Tests that pressing the enter key with a button selected correctly causes a click event for that button.
+        /// </summary>
+        private void testEnterKeySelection()
+        {
+            AddStep("Show overlay", () => pauseOverlay.Show());
+
+            AddStep("Select second button", () =>
+            {
+                pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down });
+                pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down });
+            });
+
+            var retryButton = pauseOverlay.Buttons.Skip(1).First();
+
+            bool triggered = false;
+            AddStep("Press enter", () =>
+            {
+                var lastAction = pauseOverlay.OnRetry;
+                pauseOverlay.OnRetry = () => triggered = true;
+
+                retryButton.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Enter });
+                pauseOverlay.OnRetry = lastAction;
+            });
+
+            AddAssert("Action was triggered", () => triggered);
+            AddAssert("Overlay is closed", () => pauseOverlay.State == Visibility.Hidden);
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseGraph.cs

@@ -8,7 +8,7 @@ using OpenTK;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseGraph : OsuTestCase
+    public class TestCaseGraph : OsuTestCase
     {
         public TestCaseGraph()
         {

osu.Game.Tests/Visual/TestCaseHistoricalSection.cs

@@ -0,0 +1,47 @@
+// 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 osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Overlays.Profile.Sections;
+using osu.Game.Overlays.Profile.Sections.Historical;
+using osu.Game.Users;
+
+namespace osu.Game.Tests.Visual
+{
+    public class TestCaseHistoricalSection : OsuTestCase
+    {
+        public override IReadOnlyList<Type> RequiredTypes =>
+            new[]
+            {
+                typeof(HistoricalSection),
+                typeof(PaginatedMostPlayedBeatmapContainer),
+                typeof(DrawableMostPlayedRow),
+                typeof(DrawableProfileRow)
+            };
+
+        public TestCaseHistoricalSection()
+        {
+            HistoricalSection section;
+
+            Add(new Box
+            {
+                RelativeSizeAxes = Axes.Both,
+                Colour = OsuColour.Gray(0.2f)
+            });
+
+            Add(new ScrollContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = section = new HistoricalSection(),
+            });
+
+            AddStep("Show peppy", () => section.User.Value = new User { Id = 2 });
+            AddStep("Show WubWoofWolf", () => section.User.Value = new User { Id = 39828 });
+        }
+    }
+}

osu.Game.Tests/Visual/TestCaseKeyCounter.cs

@@ -8,7 +8,7 @@ using OpenTK.Input;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseKeyCounter : OsuTestCase
+    public class TestCaseKeyCounter : OsuTestCase
     {
         public TestCaseKeyCounter()
         {

osu.Game.Tests/Visual/TestCaseLeaderboard.cs

@@ -6,14 +6,44 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Select.Leaderboards;
 using osu.Game.Users;
+using osu.Framework.Allocation;
 using OpenTK;
+using System.Linq;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets;
 
 namespace osu.Game.Tests.Visual
 {
     [Description("PlaySongSelect leaderboard")]
-    internal class TestCaseLeaderboard : OsuTestCase
+    public class TestCaseLeaderboard : OsuTestCase
     {
-        private readonly Leaderboard leaderboard;
+        private RulesetStore rulesets;
+
+        private readonly FailableLeaderboard leaderboard;
+
+        public TestCaseLeaderboard()
+        {
+            Add(leaderboard = new FailableLeaderboard
+            {
+                Origin = Anchor.Centre,
+                Anchor = Anchor.Centre,
+                Size = new Vector2(550f, 450f),
+                Scope = LeaderboardScope.Global,
+            });
+
+            AddStep(@"New Scores", newScores);
+            AddStep(@"Empty Scores", () => leaderboard.SetRetrievalState(PlaceholderState.NoScores));
+            AddStep(@"Network failure", () => leaderboard.SetRetrievalState(PlaceholderState.NetworkFailure));
+            AddStep(@"No supporter", () => leaderboard.SetRetrievalState(PlaceholderState.NotSupporter));
+            AddStep(@"Not logged in", () => leaderboard.SetRetrievalState(PlaceholderState.NotLoggedIn));
+            AddStep(@"Real beatmap", realBeatmap);
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(RulesetStore rulesets)
+        {
+            this.rulesets = rulesets;
+        }
 
         private void newScores()
         {
@@ -204,17 +234,44 @@ namespace osu.Game.Tests.Visual
             leaderboard.Scores = scores;
         }
 
-        public TestCaseLeaderboard()
+        private void realBeatmap()
         {
-            Add(leaderboard = new Leaderboard
+            leaderboard.Beatmap = new BeatmapInfo
             {
-                Origin = Anchor.Centre,
-                Anchor = Anchor.Centre,
-                Size = new Vector2(550f, 450f),
-            });
+                StarDifficulty = 1.36,
+                Version = @"BASIC",
+                OnlineBeatmapID = 1113057,
+                Ruleset = rulesets.GetRuleset(0),
+                BaseDifficulty = new BeatmapDifficulty
+                {
+                    CircleSize = 4,
+                    DrainRate = 6.5f,
+                    OverallDifficulty = 6.5f,
+                    ApproachRate = 5,
+                },
+                OnlineInfo = new BeatmapOnlineInfo
+                {
+                    Length = 115000,
+                    CircleCount = 265,
+                    SliderCount = 71,
+                    PlayCount = 47906,
+                    PassCount = 19899,
+                },
+                Metrics = new BeatmapMetrics
+                {
+                    Ratings = Enumerable.Range(0, 11),
+                    Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6),
+                    Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6),
+                },
+            };
+        }
 
-            AddStep(@"New Scores", newScores);
-            newScores();
+        private class FailableLeaderboard : Leaderboard
+        {
+            public void SetRetrievalState(PlaceholderState state)
+            {
+                PlaceholderState = state;
+            }
         }
     }
 }

osu.Game.Tests/Visual/TestCaseMedalOverlay.cs

@@ -9,7 +9,7 @@ using osu.Game.Users;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseMedalOverlay : OsuTestCase
+    public class TestCaseMedalOverlay : OsuTestCase
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Game.Tests/Visual/TestCaseMenuOverlays.cs

@@ -1,57 +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.ComponentModel;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Logging;
-using osu.Game.Screens.Play;
-
-namespace osu.Game.Tests.Visual
-{
-    [Description("player pause/fail screens")]
-    internal class TestCaseMenuOverlays : OsuTestCase
-    {
-        public TestCaseMenuOverlays()
-        {
-            FailOverlay failOverlay;
-            PauseContainer.PauseOverlay pauseOverlay;
-
-            var retryCount = 0;
-
-            Add(pauseOverlay = new PauseContainer.PauseOverlay
-            {
-                OnResume = () => Logger.Log(@"Resume"),
-                OnRetry = () => Logger.Log(@"Retry"),
-                OnQuit = () => Logger.Log(@"Quit"),
-            });
-            Add(failOverlay = new FailOverlay
-            {
-                OnRetry = () => Logger.Log(@"Retry"),
-                OnQuit = () => Logger.Log(@"Quit"),
-            });
-
-            AddStep(@"Pause", delegate
-            {
-                if (failOverlay.State == Visibility.Visible)
-                {
-                    failOverlay.Hide();
-                }
-                pauseOverlay.Show();
-            });
-            AddStep("Fail", delegate
-            {
-                if (pauseOverlay.State == Visibility.Visible)
-                {
-                    pauseOverlay.Hide();
-                }
-                failOverlay.Show();
-            });
-            AddStep("Add Retry", delegate
-            {
-                retryCount++;
-                pauseOverlay.Retries = retryCount;
-                failOverlay.Retries = retryCount;
-            });
-        }
-    }
-}

osu.Game.Tests/Visual/TestCaseMods.cs

@@ -8,17 +8,25 @@ using osu.Game.Overlays.Mods;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Play.HUD;
 using OpenTK;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using System.Linq;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.Sprites;
+using OpenTK.Graphics;
 
 namespace osu.Game.Tests.Visual
 {
     [Description("mod select and icon display")]
-    internal class TestCaseMods : OsuTestCase
+    public class TestCaseMods : OsuTestCase
     {
-        private ModSelectOverlay modSelect;
-        private ModDisplay modDisplay;
+        private const string unranked_suffix = " (Unranked)";
 
         private RulesetStore rulesets;
-
+        private ModDisplay modDisplay;
+        private TestModSelectOverlay modSelect;
 
         [BackgroundDependencyLoader]
         private void load(RulesetStore rulesets)
@@ -30,7 +38,7 @@ namespace osu.Game.Tests.Visual
         {
             base.LoadComplete();
 
-            Add(modSelect = new ModSelectOverlay
+            Add(modSelect = new TestModSelectOverlay
             {
                 RelativeSizeAxes = Axes.X,
                 Origin = Anchor.BottomCentre,
@@ -48,9 +56,156 @@ namespace osu.Game.Tests.Visual
             modDisplay.Current.BindTo(modSelect.SelectedMods);
 
             AddStep("Toggle", modSelect.ToggleVisibility);
+            AddStep("Hide", modSelect.Hide);
+            AddStep("Show", modSelect.Show);
 
-            foreach (var ruleset in rulesets.AvailableRulesets)
-                AddStep(ruleset.CreateInstance().Description, () => modSelect.Ruleset.Value = ruleset);
+            foreach (var rulesetInfo in rulesets.AvailableRulesets)
+            {
+                Ruleset ruleset = rulesetInfo.CreateInstance();
+                AddStep($"switch to {ruleset.Description}", () => modSelect.Ruleset.Value = rulesetInfo);
+
+                switch (ruleset) {
+                    case OsuRuleset or:
+                        testOsuMods(or);
+                        break;
+                }
+            }
+        }
+
+        private void testOsuMods(OsuRuleset ruleset)
+        {
+            var easierMods = ruleset.GetModsFor(ModType.DifficultyReduction);
+            var harderMods = ruleset.GetModsFor(ModType.DifficultyIncrease);
+            var assistMods = ruleset.GetModsFor(ModType.Special);
+
+            var noFailMod = easierMods.FirstOrDefault(m => m is OsuModNoFail);
+            var hiddenMod = harderMods.FirstOrDefault(m => m is OsuModHidden);
+            var doubleTimeMod = harderMods.OfType<MultiMod>().FirstOrDefault(m => m.Mods.Any(a => a is OsuModDoubleTime));
+            var autoPilotMod = assistMods.FirstOrDefault(m => m is OsuModAutopilot);
+
+            testSingleMod(noFailMod);
+            testMultiMod(doubleTimeMod);
+            testIncompatibleMods(noFailMod, autoPilotMod);
+            testDeselectAll(easierMods.Where(m => !(m is MultiMod)));
+            testMultiplierTextColour(noFailMod, modSelect.LowMultiplierColour);
+            testMultiplierTextColour(hiddenMod, modSelect.HighMultiplierColour);
+            testMultiplierTextUnranked(autoPilotMod);
+        }
+
+        private void testSingleMod(Mod mod)
+        {
+            selectNext(mod);
+            checkSelected(mod);
+
+            selectPrevious(mod);
+            checkNotSelected(mod);
+
+            selectNext(mod);
+            selectNext(mod);
+            checkNotSelected(mod);
+
+            selectPrevious(mod);
+            selectPrevious(mod);
+            checkNotSelected(mod);
+        }
+
+        private void testMultiMod(MultiMod multiMod)
+        {
+            foreach (var mod in multiMod.Mods)
+            {
+                selectNext(mod);
+                checkSelected(mod);
+            }
+
+            for (int index = multiMod.Mods.Length - 1; index >= 0; index--)
+                selectPrevious(multiMod.Mods[index]);
+
+            foreach (var mod in multiMod.Mods)
+                checkNotSelected(mod);
+        }
+
+        private void testIncompatibleMods(Mod modA, Mod modB)
+        {
+            selectNext(modA);
+            checkSelected(modA);
+            checkNotSelected(modB);
+
+            selectNext(modB);
+            checkSelected(modB);
+            checkNotSelected(modA);
+
+            selectPrevious(modB);
+            checkNotSelected(modA);
+            checkNotSelected(modB);
+        }
+
+        private void testDeselectAll(IEnumerable<Mod> mods)
+        {
+            foreach (var mod in mods)
+                selectNext(mod);
+
+            AddAssert("check for any selection", () => modSelect.SelectedMods.Value.Any());
+            AddStep("deselect all", modSelect.DeselectAllButton.Action.Invoke);
+            AddAssert("check for no selection", () => !modSelect.SelectedMods.Value.Any());
+        }
+
+        private void testMultiplierTextColour(Mod mod, Color4 colour)
+        {
+            checkLabelColor(Color4.White);
+            selectNext(mod);
+            AddWaitStep(1, "wait for changing colour");
+            checkLabelColor(colour);
+            selectPrevious(mod);
+            AddWaitStep(1, "wait for changing colour");
+            checkLabelColor(Color4.White);
+        }
+
+        private void testMultiplierTextUnranked(Mod mod)
+        {
+            AddAssert("check for ranked", () => !modSelect.MultiplierLabel.Text.EndsWith(unranked_suffix));
+            selectNext(mod);
+            AddAssert("check for unranked", () => modSelect.MultiplierLabel.Text.EndsWith(unranked_suffix));
+            selectPrevious(mod);
+            AddAssert("check for ranked", () => !modSelect.MultiplierLabel.Text.EndsWith(unranked_suffix));
+        }
+
+        private void selectNext(Mod mod) => AddStep($"left click {mod.Name}", () => modSelect.GetModButton(mod)?.SelectNext());
+
+        private void selectPrevious(Mod mod) => AddStep($"right click {mod.Name}", () => modSelect.GetModButton(mod)?.SelectPrevious());
+
+        private void checkSelected(Mod mod)
+        {
+            AddAssert($"check {mod.Name} is selected", () =>
+            {
+                var button = modSelect.GetModButton(mod);
+                return modSelect.SelectedMods.Value.Single(m => m.Name == mod.Name) != null && button.SelectedMod.GetType() == mod.GetType() && button.Selected;
+            });
+        }
+
+        private void checkNotSelected(Mod mod)
+        {
+            AddAssert($"check {mod.Name} is not selected", () =>
+            {
+                var button = modSelect.GetModButton(mod);
+                return modSelect.SelectedMods.Value.All(m => m.GetType() != mod.GetType()) && button.SelectedMod?.GetType() != mod.GetType();
+            });
+        }
+
+        private void checkLabelColor(Color4 color) => AddAssert("check label has expected colour", () => modSelect.MultiplierLabel.Colour.AverageColour == color);
+
+        private class TestModSelectOverlay : ModSelectOverlay
+        {
+            public ModButton GetModButton(Mod mod)
+            {
+                var section = ModSectionsContainer.Children.Single(s => s.ModType == mod.Type);
+                return section.ButtonsContainer.OfType<ModButton>().Single(b => b.Mods.Any(m => m.GetType() == mod.GetType()));
+            }
+
+            public new OsuSpriteText MultiplierLabel => base.MultiplierLabel;
+            public new TriangleButton DeselectAllButton => base.DeselectAllButton;
+
+            public new Color4 LowMultiplierColour => base.LowMultiplierColour;
+            public new Color4 HighMultiplierColour => base.HighMultiplierColour;
         }
     }
 }

osu.Game.Tests/Visual/TestCaseMusicController.cs

@@ -11,7 +11,7 @@ using osu.Game.Overlays;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseMusicController : OsuTestCase
+    public class TestCaseMusicController : OsuTestCase
     {
         private readonly Bindable<WorkingBeatmap> beatmapBacking = new Bindable<WorkingBeatmap>();
 

osu.Game.Tests/Visual/TestCaseNotificationOverlay.cs

@@ -13,7 +13,7 @@ using osu.Game.Overlays.Notifications;
 namespace osu.Game.Tests.Visual
 {
     [TestFixture]
-    internal class TestCaseNotificationOverlay : OsuTestCase
+    public class TestCaseNotificationOverlay : OsuTestCase
     {
         private readonly NotificationOverlay manager;
 
@@ -82,7 +82,11 @@ namespace osu.Game.Tests.Visual
 
         private void sendProgress2()
         {
-            var n = new ProgressNotification { Text = @"Downloading Haitai..." };
+            var n = new ProgressNotification
+            {
+                Text = @"Downloading Haitai...",
+                CompletionText = "Downloaded Haitai!",
+            };
             manager.Post(n);
             progressingNotifications.Add(n);
         }
@@ -91,7 +95,11 @@ namespace osu.Game.Tests.Visual
 
         private void sendProgress1()
         {
-            var n = new ProgressNotification { Text = @"Uploading to BSS..." };
+            var n = new ProgressNotification
+            {
+                Text = @"Uploading to BSS...",
+                CompletionText = "Uploaded to BSS!",
+            };
             manager.Post(n);
             progressingNotifications.Add(n);
         }

osu.Game.Tests/Visual/TestCaseOnScreenDisplay.cs

@@ -7,7 +7,7 @@ using osu.Game.Overlays;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCaseOnScreenDisplay : OsuTestCase
+    public class TestCaseOnScreenDisplay : OsuTestCase
     {
         private FrameworkConfigManager config;
         private Bindable<FrameSync> frameSyncMode;

osu.Game.Tests/Visual/TestCasePlaySongSelect.cs

@@ -13,12 +13,13 @@ using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Carousel;
 using osu.Game.Screens.Select.Filter;
 using osu.Game.Tests.Platform;
 
 namespace osu.Game.Tests.Visual
 {
-    internal class TestCasePlaySongSelect : OsuTestCase
+    public class TestCasePlaySongSelect : OsuTestCase
     {
         private BeatmapManager manager;
 
@@ -26,10 +27,28 @@ namespace osu.Game.Tests.Visual
 
         private DependencyContainer dependencies;
 
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(SongSelect),
+            typeof(BeatmapCarousel),
+
+            typeof(CarouselItem),
+            typeof(CarouselGroup),
+            typeof(CarouselGroupEagerSelect),
+            typeof(CarouselBeatmap),
+            typeof(CarouselBeatmapSet),
+
+            typeof(DrawableCarouselItem),
+            typeof(CarouselItemState),
+
+            typeof(DrawableCarouselBeatmap),
+            typeof(DrawableCarouselBeatmapSet),
+        };
+
         protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent) => dependencies = new DependencyContainer(parent);
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(BeatmapManager baseManager)
         {
             PlaySongSelect songSelect;
 
@@ -43,7 +62,10 @@ namespace osu.Game.Tests.Visual
                 Func<OsuDbContext> contextFactory = () => context;
 
                 dependencies.Cache(rulesets = new RulesetStore(contextFactory));
-                dependencies.Cache(manager = new BeatmapManager(storage, contextFactory, rulesets, null));
+                dependencies.Cache(manager = new BeatmapManager(storage, contextFactory, rulesets, null)
+                {
+                    DefaultBeatmap = baseManager.GetWorkingBeatmap(null)
+                });
 
                 for (int i = 0; i < 100; i += 10)
                     manager.Import(createTestBeatmapSet(i));