Update squirrel for more diagnostics

Reduce beatmap difficulty processing time

appveyor_deploy.yml

@@ -10,8 +10,8 @@ before_build:
   - cmd: nuget restore -verbosity quiet
 build_script:
   - ps: iex ((New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/appveyor/secure-file/master/install.ps1'))
-  - appveyor DownloadFile https://puu.sh/A6g5K/4d08705438.enc # signing certificate
-  - cmd: appveyor-tools\secure-file -decrypt 4d08705438.enc -secret %decode_secret% -out %HOMEPATH%\deanherbert.pfx
+  - appveyor DownloadFile https://www.dropbox.com/s/f7hv069mr5tqi2j/deanherbert.pfx.enc?dl=1 # signing certificate
+  - cmd: appveyor-tools\secure-file -decrypt deanherbert.pfx.enc -secret %decode_secret% -out %HOMEPATH%\deanherbert.pfx
   - appveyor DownloadFile https://puu.sh/A6g75/fdc6f19b04.enc # deploy configuration
   - cd osu-deploy
   - nuget restore -verbosity quiet

osu.Desktop/Overlays/VersionManager.cs

@@ -27,9 +27,6 @@ namespace osu.Desktop.Overlays
         private NotificationOverlay notificationOverlay;
         private GameHost host;
 
-        public override bool HandleKeyboardInput => false;
-        public override bool HandleMouseInput => false;
-
         [BackgroundDependencyLoader]
         private void load(NotificationOverlay notification, OsuColour colours, TextureStore textures, OsuGameBase game, OsuConfigManager config, GameHost host)
         {

osu.Desktop/osu.Desktop.csproj

@@ -27,9 +27,9 @@
   </ItemGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="System.IO.Packaging" Version="4.5.0" />
-    <PackageReference Include="ppy.squirrel.windows" Version="1.8.0.5" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.2" />
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.1.2" />
+    <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.1" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.1.4" />
   </ItemGroup>
   <ItemGroup Label="Resources">
     <EmbeddedResource Include="lazer.ico" />

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

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
@@ -38,7 +37,7 @@ namespace osu.Game.Rulesets.Catch.Tests
                 beatmap.HitObjects.Add(new JuiceStream
                 {
                     X = 0.5f - width / 2,
-                    ControlPoints = new List<Vector2>
+                    ControlPoints = new[]
                     {
                         Vector2.Zero,
                         new Vector2(width * CatchPlayfield.BASE_WIDTH, 0)

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

@@ -2,9 +2,10 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
-    <PackageReference Include="NUnit" Version="3.10.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="NUnit" Version="3.11.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.10.0" />
+    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

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

@@ -74,42 +74,42 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
 
         private void initialiseHyperDash(List<CatchHitObject> objects)
         {
-            // todo: add difficulty adjust.
-            double halfCatcherWidth = CatcherArea.CATCHER_SIZE * (objects.FirstOrDefault()?.Scale ?? 1) / CatchPlayfield.BASE_WIDTH / 2;
+            List<CatchHitObject> objectWithDroplets = new List<CatchHitObject>();
 
+            foreach (var currentObject in objects)
+            {
+                if (currentObject is Fruit)
+                    objectWithDroplets.Add(currentObject);
+                if (currentObject is JuiceStream)
+                    foreach (var currentJuiceElement in currentObject.NestedHitObjects)
+                        if (!(currentJuiceElement is TinyDroplet))
+                            objectWithDroplets.Add((CatchHitObject)currentJuiceElement);
+            }
+
+            objectWithDroplets.Sort((h1, h2) => h1.StartTime.CompareTo(h2.StartTime));
+
+            double halfCatcherWidth = CatcherArea.GetCatcherSize(Beatmap.BeatmapInfo.BaseDifficulty) / 2;
             int lastDirection = 0;
             double lastExcess = halfCatcherWidth;
 
-            int objCount = objects.Count;
-
-            for (int i = 0; i < objCount - 1; i++)
+            for (int i = 0; i < objectWithDroplets.Count - 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];
-                // }
+                CatchHitObject currentObject = objectWithDroplets[i];
+                CatchHitObject nextObject = objectWithDroplets[i + 1];
 
                 int thisDirection = nextObject.X > currentObject.X ? 1 : -1;
-                double timeToNext = nextObject.StartTime - ((currentObject as IHasEndTime)?.EndTime ?? currentObject.StartTime) - 4;
+                double timeToNext = nextObject.StartTime - currentObject.StartTime;
                 double distanceToNext = Math.Abs(nextObject.X - currentObject.X) - (lastDirection == thisDirection ? lastExcess : halfCatcherWidth);
-
-                if (timeToNext * CatcherArea.Catcher.BASE_SPEED < distanceToNext)
+                float distanceToHyper = (float)(timeToNext * CatcherArea.Catcher.BASE_SPEED - distanceToNext);
+                if (distanceToHyper < 0)
                 {
                     currentObject.HyperDashTarget = nextObject;
                     lastExcess = halfCatcherWidth;
                 }
                 else
                 {
-                    //currentObject.DistanceToHyperDash = timeToNext - distanceToNext;
-                    lastExcess = MathHelper.Clamp(timeToNext - distanceToNext, 0, halfCatcherWidth);
+                    currentObject.DistanceToHyperDash = distanceToHyper;
+                    lastExcess = MathHelper.Clamp(distanceToHyper, 0, halfCatcherWidth);
                 }
 
                 lastDirection = thisDirection;

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public int IndexInBeatmap { get; set; }
 
-        public virtual FruitVisualRepresentation VisualRepresentation => (FruitVisualRepresentation)(IndexInBeatmap % 4);
+        public virtual FruitVisualRepresentation VisualRepresentation => (FruitVisualRepresentation)(ComboIndex % 4);
 
         public virtual bool NewCombo { get; set; }
 
@@ -27,7 +27,9 @@ namespace osu.Game.Rulesets.Catch.Objects
         public int ComboIndex { get; set; }
 
         /// <summary>
-        /// The distance for a fruit to to next hyper if it's not a hyper.
+        /// Difference between the distance to the next object
+        /// and the distance that would have triggered a hyper dash.
+        /// A value close to 0 indicates a difficult jump (for difficulty calculation).
         /// </summary>
         public float DistanceToHyperDash { get; set; }
 

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

@@ -146,7 +146,7 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public SliderCurve Curve { get; } = new SliderCurve();
 
-        public List<Vector2> ControlPoints
+        public Vector2[] ControlPoints
         {
             get { return Curve.ControlPoints; }
             set { Curve.ControlPoints = value; }

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

@@ -5,11 +5,13 @@ using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
+using OpenTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -17,13 +19,13 @@ namespace osu.Game.Rulesets.Catch.UI
     {
         public const float BASE_WIDTH = 512;
 
-        protected override Container<Drawable> Content => content;
-        private readonly Container<Drawable> content;
-
         private readonly CatcherArea catcherArea;
 
+        protected override bool UserScrollSpeedAdjustment => false;
+
+        protected override SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Constant;
+
         public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation)
-            : base(BASE_WIDTH)
         {
             Direction.Value = ScrollingDirection.Down;
 
@@ -32,27 +34,29 @@ namespace osu.Game.Rulesets.Catch.UI
             Anchor = Anchor.TopCentre;
             Origin = Anchor.TopCentre;
 
-            base.Content.Anchor = Anchor.BottomLeft;
-            base.Content.Origin = Anchor.BottomLeft;
+            Size = new Vector2(0.86f); // matches stable's vertical offset for catcher plate
 
-            base.Content.AddRange(new Drawable[]
+            InternalChild = new PlayfieldAdjustmentContainer
             {
-                explodingFruitContainer = new Container
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
                 {
-                    RelativeSizeAxes = Axes.Both,
-                },
-                catcherArea = new CatcherArea(difficulty)
-                {
-                    GetVisualRepresentation = getVisualRepresentation,
-                    ExplodingFruitTarget = explodingFruitContainer,
-                    Anchor = Anchor.BottomLeft,
-                    Origin = Anchor.TopLeft,
-                },
-                content = new Container<Drawable>
-                {
-                    RelativeSizeAxes = Axes.Both,
-                },
-            });
+                    explodingFruitContainer = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    catcherArea = new CatcherArea(difficulty)
+                    {
+                        GetVisualRepresentation = getVisualRepresentation,
+                        ExplodingFruitTarget = explodingFruitContainer,
+                        Anchor = Anchor.BottomLeft,
+                        Origin = Anchor.TopLeft,
+                    },
+                    HitObjectContainer
+                }
+            };
+
+            VisibleTimeRange.Value = BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450);
         }
 
         public bool CheckIfWeCanCatch(CatchHitObject obj) => catcherArea.AttemptCatch(obj);

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

@@ -13,7 +13,6 @@ using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -32,8 +31,6 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public override PassThroughInputManager CreateInputManager() => new CatchInputManager(Ruleset.RulesetInfo);
 
-        protected override Vector2 PlayfieldArea => new Vector2(0.86f); // matches stable's vertical offset for catcher plate
-
         protected override DrawableHitObject<CatchHitObject> GetVisualRepresentation(CatchHitObject h)
         {
             switch (h)

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

@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Catch.UI
 {
     public class CatcherArea : Container
     {
-        public const float CATCHER_SIZE = 84;
+        public const float CATCHER_SIZE = 100;
 
         protected readonly Catcher MovableCatcher;
 
@@ -107,6 +107,11 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public bool AttemptCatch(CatchHitObject obj) => MovableCatcher.AttemptCatch(obj);
 
+        public static float GetCatcherSize(BeatmapDifficulty difficulty)
+        {
+            return CATCHER_SIZE / CatchPlayfield.BASE_WIDTH * (1.0f - 0.7f * (difficulty.CircleSize - 5) / 5);
+        }
+
         public class Catcher : Container, IKeyBindingHandler<CatchAction>
         {
             /// <summary>

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

@@ -0,0 +1,42 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Catch.UI
+{
+    public class PlayfieldAdjustmentContainer : Container
+    {
+        protected override Container<Drawable> Content => content;
+        private readonly Container content;
+
+        public PlayfieldAdjustmentContainer()
+        {
+            InternalChild = new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                FillMode = FillMode.Fit,
+                FillAspectRatio = 4f / 3,
+                Child = content = new ScalingContainer { RelativeSizeAxes = Axes.Both }
+            };
+        }
+
+        /// <summary>
+        /// A <see cref="Container"/> which scales its content relative to a target width.
+        /// </summary>
+        private class ScalingContainer : Container
+        {
+            protected override void Update()
+            {
+                base.Update();
+
+                Scale = new Vector2(Parent.ChildSize.X / CatchPlayfield.BASE_WIDTH);
+                Size = Vector2.Divide(Vector2.One, Scale);
+            }
+        }
+    }
+}

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

@@ -2,9 +2,10 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
-    <PackageReference Include="NUnit" Version="3.10.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="NUnit" Version="3.11.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.10.0" />
+    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                 TargetColumns = (int)Math.Max(1, roundedCircleSize);
             else
             {
-                float percentSliderOrSpinner = (float)beatmap.HitObjects.Count(h => h is IHasEndTime) / beatmap.HitObjects.Count();
+                float percentSliderOrSpinner = (float)beatmap.HitObjects.Count(h => h is IHasEndTime) / beatmap.HitObjects.Count;
                 if (percentSliderOrSpinner < 0.2)
                     TargetColumns = 7;
                 else if (percentSliderOrSpinner < 0.3 || roundedCircleSize >= 5)

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PatternGenerator.cs

@@ -112,7 +112,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     drainTime = 10000;
 
                 BeatmapDifficulty difficulty = OriginalBeatmap.BeatmapInfo.BaseDifficulty;
-                conversionDifficulty = ((difficulty.DrainRate + MathHelper.Clamp(difficulty.ApproachRate, 4, 7)) / 1.5 + (double)OriginalBeatmap.HitObjects.Count() / drainTime * 9f) / 38f * 5f / 1.15;
+                conversionDifficulty = ((difficulty.DrainRate + MathHelper.Clamp(difficulty.ApproachRate, 4, 7)) / 1.5 + (double)OriginalBeatmap.HitObjects.Count / drainTime * 9f) / 38f * 5f / 1.15;
                 conversionDifficulty = Math.Min(conversionDifficulty.Value, 12);
 
                 return conversionDifficulty.Value;

osu.Game.Rulesets.Mania/Configuration/ManiaConfigManager.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
         {
             base.InitialiseDefaults();
 
-            Set(ManiaSetting.ScrollTime, 1500.0, 50.0, 10000.0, 50.0);
+            Set(ManiaSetting.ScrollTime, 2250.0, 50.0, 10000.0, 50.0);
             Set(ManiaSetting.ScrollDirection, ManiaScrollingDirection.Down);
         }
 

osu.Game.Rulesets.Mania/Edit/Layers/Selection/Overlays/HoldNoteMask.cs

@@ -78,7 +78,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Layers.Selection.Overlays
             }
 
             // Todo: This is temporary, since the note masks don't do anything special yet. In the future they will handle input.
-            public override bool HandleMouseInput => false;
+            public override bool HandlePositionalInput => false;
         }
     }
 }

osu.Game.Rulesets.Mania/Edit/ManiaEditRulesetContainer.cs

@@ -20,8 +20,7 @@ namespace osu.Game.Rulesets.Mania.Edit
         {
             Anchor = Anchor.Centre,
             Origin = Anchor.Centre,
+            Size = Vector2.One
         };
-
-        protected override Vector2 PlayfieldArea => Vector2.One;
     }
 }

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

@@ -30,8 +30,6 @@ namespace osu.Game.Rulesets.Mania.UI
         internal readonly Container TopLevelContainer;
         private readonly Container explosionContainer;
 
-        protected override Container<Drawable> Content => hitObjectArea;
-
         public Column()
         {
             RelativeSizeAxes = Axes.Y;
@@ -54,7 +52,10 @@ namespace osu.Game.Rulesets.Mania.UI
                     RelativeSizeAxes = Axes.Both,
                     Children = new Drawable[]
                     {
-                        hitObjectArea = new ColumnHitObjectArea { RelativeSizeAxes = Axes.Both },
+                        hitObjectArea = new ColumnHitObjectArea(HitObjectContainer)
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                        },
                         explosionContainer = new Container
                         {
                             Name = "Hit explosions",

osu.Game.Rulesets.Mania/UI/Components/ColumnHitObjectArea.cs

@@ -8,28 +8,24 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI.Components
 {
-    public class ColumnHitObjectArea : Container, IHasAccentColour
+    public class ColumnHitObjectArea : CompositeDrawable, IHasAccentColour
     {
         private const float hit_target_height = 10;
         private const float hit_target_bar_height = 2;
 
-        private Container<Drawable> content;
-        protected override Container<Drawable> Content => content;
-
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
 
-        private Container hitTargetLine;
+        private readonly Container hitTargetLine;
+        private readonly Drawable hitTargetBar;
 
-        [BackgroundDependencyLoader]
-        private void load(IScrollingInfo scrollingInfo)
+        public ColumnHitObjectArea(HitObjectContainer hitObjectContainer)
         {
-            Drawable hitTargetBar;
-
             InternalChildren = new[]
             {
                 hitTargetBar = new Box
@@ -45,13 +41,13 @@ namespace osu.Game.Rulesets.Mania.UI.Components
                     Masking = true,
                     Child = new Box { RelativeSizeAxes = Axes.Both }
                 },
-                content = new Container
-                {
-                    Name = "Hit objects",
-                    RelativeSizeAxes = Axes.Both,
-                },
+                hitObjectContainer
             };
+        }
 
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
             direction.BindTo(scrollingInfo.Direction);
             direction.BindValueChanged(direction =>
             {

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

@@ -30,10 +30,11 @@ namespace osu.Game.Rulesets.Mania.UI
 
             if (Result.IsHit)
             {
-                this.ScaleTo(0.8f);
-                this.ScaleTo(1, 250, Easing.OutElastic);
+                JudgementBody.ScaleTo(0.8f);
+                JudgementBody.ScaleTo(1, 250, Easing.OutElastic);
 
-                this.Delay(50).FadeOut(200).ScaleTo(0.75f, 250);
+                JudgementBody.Delay(50).ScaleTo(0.75f, 250);
+                this.Delay(50).FadeOut(200);
             }
 
             Expire();

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

@@ -10,6 +10,7 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using OpenTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -25,6 +26,8 @@ namespace osu.Game.Rulesets.Mania.UI
             if (stageDefinitions.Count <= 0)
                 throw new ArgumentException("Can't have zero or fewer stages.");
 
+            Size = new Vector2(1, 0.8f);
+
             GridContainer playfieldGrid;
             AddInternal(playfieldGrid = new GridContainer
             {

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

@@ -24,7 +24,6 @@ using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -110,8 +109,6 @@ namespace osu.Game.Rulesets.Mania.UI
             }
         }
 
-        protected override Vector2 PlayfieldArea => new Vector2(1, 0.8f);
-
         protected override ReplayInputHandler CreateReplayInputHandler(Replay replay) => new ManiaFramedReplayInputHandler(replay);
     }
 }

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

@@ -7,7 +7,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class ManiaScrollingPlayfield : ScrollingPlayfield
+    public abstract class ManiaScrollingPlayfield : ScrollingPlayfield
     {
         private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
 

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

@@ -30,8 +30,7 @@ namespace osu.Game.Rulesets.Mania.UI
         public IReadOnlyList<Column> Columns => columnFlow.Children;
         private readonly FillFlowContainer<Column> columnFlow;
 
-        protected override Container<Drawable> Content => barLineContainer;
-        private readonly Container<Drawable> barLineContainer;
+        private readonly Container barLineContainer;
 
         public Container<DrawableManiaJudgement> Judgements => judgements;
         private readonly JudgementContainer<DrawableManiaJudgement> judgements;
@@ -105,6 +104,7 @@ namespace osu.Game.Rulesets.Mania.UI
                                 Anchor = Anchor.TopCentre,
                                 Origin = Anchor.TopCentre,
                                 RelativeSizeAxes = Axes.Y,
+                                Child = HitObjectContainer
                             }
                         },
                         judgements = new JudgementContainer<DrawableManiaJudgement>

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

@@ -108,7 +108,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(239, 176),
-                ControlPoints = new List<Vector2>
+                ControlPoints = new[]
                 {
                     Vector2.Zero,
                     new Vector2(154, 28),
@@ -141,7 +141,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-(distance / 2), 0),
-                ControlPoints = new List<Vector2>
+                ControlPoints = new[]
                 {
                     Vector2.Zero,
                     new Vector2(distance, 0),
@@ -161,7 +161,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-200, 0),
-                ControlPoints = new List<Vector2>
+                ControlPoints = new[]
                 {
                     Vector2.Zero,
                     new Vector2(200, 200),
@@ -184,7 +184,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 CurveType = CurveType.Linear,
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-200, 0),
-                ControlPoints = new List<Vector2>
+                ControlPoints = new[]
                 {
                     Vector2.Zero,
                     new Vector2(150, 75),
@@ -210,7 +210,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 CurveType = CurveType.Bezier,
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-200, 0),
-                ControlPoints = new List<Vector2>
+                ControlPoints = new[]
                 {
                     Vector2.Zero,
                     new Vector2(150, 75),
@@ -235,7 +235,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 CurveType = CurveType.Linear,
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(0, 0),
-                ControlPoints = new List<Vector2>
+                ControlPoints = new[]
                 {
                     Vector2.Zero,
                     new Vector2(-200, 0),
@@ -265,7 +265,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-100, 0),
                 CurveType = CurveType.Catmull,
-                ControlPoints = new List<Vector2>
+                ControlPoints = new[]
                 {
                     Vector2.Zero,
                     new Vector2(50, -50),

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

@@ -2,9 +2,10 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
-    <PackageReference Include="NUnit" Version="3.10.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="NUnit" Version="3.11.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.10.0" />
+    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs

@@ -10,6 +10,8 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
 {
     public class OsuBeatmapProcessor : BeatmapProcessor
     {
+        private const int stack_distance = 3;
+
         public OsuBeatmapProcessor(IBeatmap beatmap)
             : base(beatmap)
         {
@@ -18,17 +20,21 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
         public override void PostProcess()
         {
             base.PostProcess();
-            applyStacking((Beatmap<OsuHitObject>)Beatmap);
+
+            var osuBeatmap = (Beatmap<OsuHitObject>)Beatmap;
+
+            // Reset stacking
+            foreach (var h in osuBeatmap.HitObjects)
+                h.StackHeight = 0;
+
+            if (Beatmap.BeatmapInfo.BeatmapVersion >= 6)
+                applyStacking(osuBeatmap);
+            else
+                applyStackingOld(osuBeatmap);
         }
 
         private void applyStacking(Beatmap<OsuHitObject> beatmap)
         {
-            const int stack_distance = 3;
-
-            // Reset stacking
-            for (int i = 0; i <= beatmap.HitObjects.Count - 1; i++)
-                beatmap.HitObjects[i].StackHeight = 0;
-
             // Extend the end index to include objects they are stacked on
             int extendedEndIndex = beatmap.HitObjects.Count - 1;
             for (int i = beatmap.HitObjects.Count - 1; i >= 0; i--)
@@ -167,5 +173,40 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 }
             }
         }
+
+        private void applyStackingOld(Beatmap<OsuHitObject> beatmap)
+        {
+            for (int i = 0; i < beatmap.HitObjects.Count; i++)
+            {
+                OsuHitObject currHitObject = beatmap.HitObjects[i];
+
+                if (currHitObject.StackHeight != 0 && !(currHitObject is Slider))
+                    continue;
+
+                double startTime = (currHitObject as IHasEndTime)?.EndTime ?? currHitObject.StartTime;
+                int sliderStack = 0;
+
+                for (int j = i + 1; j < beatmap.HitObjects.Count; j++)
+                {
+                    double stackThreshold = beatmap.HitObjects[i].TimePreempt * beatmap.BeatmapInfo.StackLeniency;
+
+                    if (beatmap.HitObjects[j].StartTime - stackThreshold > startTime)
+                        break;
+
+                    if (Vector2Extensions.Distance(beatmap.HitObjects[j].Position, currHitObject.Position) < stack_distance)
+                    {
+                        currHitObject.StackHeight++;
+                        startTime = (beatmap.HitObjects[j] as IHasEndTime)?.EndTime ?? beatmap.HitObjects[i].StartTime;
+                    }
+                    else if (Vector2Extensions.Distance(beatmap.HitObjects[j].Position, currHitObject.EndPosition) < stack_distance)
+                    {
+                        //Case for sliders - bump notes down and right, rather than up and left.
+                        sliderStack++;
+                        beatmap.HitObjects[j].StackHeight -= sliderStack;
+                        startTime = (beatmap.HitObjects[j] as IHasEndTime)?.EndTime ?? beatmap.HitObjects[i].StartTime;
+                    }
+                }
+            }
+        }
     }
 }

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

@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             double sectionLength = section_length * timeRate;
 
             // The first object doesn't generate a strain, so we begin with an incremented section end
-            double currentSectionEnd = 2 * sectionLength;
+            double currentSectionEnd = Math.Ceiling(beatmap.HitObjects.First().StartTime / sectionLength) * sectionLength;
 
             foreach (OsuDifficultyHitObject h in difficultyBeatmap)
             {
@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             double hitWindowGreat = (int)(beatmap.HitObjects.First().HitWindows.Great / 2) / timeRate;
             double preempt = (int)BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / timeRate;
 
-            int maxCombo = beatmap.HitObjects.Count();
+            int maxCombo = beatmap.HitObjects.Count;
             // Add the ticks + tail of the slider. 1 is subtracted because the head circle would be counted twice (once for the slider itself in the line above)
             maxCombo += beatmap.HitObjects.OfType<Slider>().Sum(s => s.NestedHitObjects.Count - 1);
 

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

@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         {
             countHitCircles = Beatmap.HitObjects.Count(h => h is HitCircle);
 
-            beatmapMaxCombo = Beatmap.HitObjects.Count();
+            beatmapMaxCombo = Beatmap.HitObjects.Count;
             // Add the ticks + tail of the slider. 1 is subtracted because the "headcircle" would be counted twice (once for the slider itself in the line above)
             beatmapMaxCombo += Beatmap.HitObjects.OfType<Slider>().Sum(s => s.NestedHitObjects.Count - 1);
         }

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

@@ -3,6 +3,7 @@
 
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
@@ -23,8 +24,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
         {
             // 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, timeRate);
+            difficultyObjects = createDifficultyObjectEnumerator(objects.OrderBy(h => h.StartTime).ToList(), timeRate);
         }
 
         /// <summary>

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

@@ -21,15 +21,25 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
         public OsuHitObject BaseObject { get; }
 
         /// <summary>
-        /// Normalized distance from the <see cref="OsuHitObject.StackedPosition"/> of the previous <see cref="OsuDifficultyHitObject"/>.
+        /// Normalized distance from the end position of the previous <see cref="OsuDifficultyHitObject"/> to the start position of this <see cref="OsuDifficultyHitObject"/>.
         /// </summary>
-        public double Distance { get; private set; }
+        public double JumpDistance { get; private set; }
+
+        /// <summary>
+        /// Normalized distance between the start and end position of the previous <see cref="OsuDifficultyHitObject"/>.
+        /// </summary>
+        public double TravelDistance { get; private set; }
 
         /// <summary>
         /// Milliseconds elapsed since the StartTime of the previous <see cref="OsuDifficultyHitObject"/>.
         /// </summary>
         public double DeltaTime { get; private set; }
 
+        /// <summary>
+        /// Milliseconds elapsed since the start time of the previous <see cref="OsuDifficultyHitObject"/>, with a minimum of 50ms.
+        /// </summary>
+        public double StrainTime { get; private set; }
+
         private readonly OsuHitObject lastObject;
         private readonly double timeRate;
 
@@ -51,31 +61,37 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
         private void setDistances()
         {
             // We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
-            double scalingFactor = normalized_radius / BaseObject.Radius;
+            float scalingFactor = normalized_radius / (float)BaseObject.Radius;
             if (BaseObject.Radius < 30)
             {
-                double smallCircleBonus = Math.Min(30 - BaseObject.Radius, 5) / 50;
+                float smallCircleBonus = Math.Min(30 - (float)BaseObject.Radius, 5) / 50;
                 scalingFactor *= 1 + smallCircleBonus;
             }
 
             Vector2 lastCursorPosition = lastObject.StackedPosition;
-            float lastTravelDistance = 0;
 
             var lastSlider = lastObject as Slider;
             if (lastSlider != null)
             {
                 computeSliderCursorPosition(lastSlider);
                 lastCursorPosition = lastSlider.LazyEndPosition ?? lastCursorPosition;
-                lastTravelDistance = lastSlider.LazyTravelDistance;
             }
 
-            Distance = (lastTravelDistance + (BaseObject.StackedPosition - lastCursorPosition).Length) * scalingFactor;
+            // Don't need to jump to reach spinners
+            if (!(BaseObject is Spinner))
+                JumpDistance = (BaseObject.StackedPosition * scalingFactor - lastCursorPosition * scalingFactor).Length;
+
+            // Todo: BUG!!! Last slider's travel distance is considered ONLY IF we ourselves are also a slider!
+            if (BaseObject is Slider)
+                TravelDistance = (lastSlider?.LazyTravelDistance ?? 0) * 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(50, (BaseObject.StartTime - lastObject.StartTime) / timeRate);
+            DeltaTime = (BaseObject.StartTime - lastObject.StartTime) / timeRate;
+
+            // Every strain interval is hard capped at the equivalent of 375 BPM streaming speed as a safety measure
+            StrainTime = Math.Max(50, DeltaTime);
         }
 
         private void computeSliderCursorPosition(Slider slider)
@@ -87,8 +103,14 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
             float approxFollowCircleRadius = (float)(slider.Radius * 3);
             var computeVertex = new Action<double>(t =>
             {
+                double progress = ((int)t - (int)slider.StartTime) / (float)(int)slider.SpanDuration;
+                if (progress % 2 > 1)
+                    progress = 1 - progress % 1;
+                else
+                    progress = progress % 1;
+
                 // ReSharper disable once PossibleInvalidOperationException (bugged in current r# version)
-                var diff = slider.StackedPositionAt(t) - slider.LazyEndPosition.Value;
+                var diff = slider.StackedPosition + slider.Curve.PositionAt(progress) - slider.LazyEndPosition.Value;
                 float dist = diff.Length;
 
                 if (dist > approxFollowCircleRadius)

osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs

@@ -14,6 +14,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
         protected override double SkillMultiplier => 26.25;
         protected override double StrainDecayBase => 0.15;
 
-        protected override double StrainValueOf(OsuDifficultyHitObject current) => Math.Pow(current.Distance, 0.99) / current.DeltaTime;
+        protected override double StrainValueOf(OsuDifficultyHitObject current)
+            => (Math.Pow(current.TravelDistance, 0.99) + Math.Pow(current.JumpDistance, 0.99)) / current.StrainTime;
     }
 }

osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
 
         protected override double StrainValueOf(OsuDifficultyHitObject current)
         {
-            double distance = current.Distance;
+            double distance = current.TravelDistance + current.JumpDistance;
 
             double speedValue;
             if (distance > single_spacing_threshold)
@@ -33,7 +33,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
             else
                 speedValue = 0.95;
 
-            return speedValue / current.DeltaTime;
+            return speedValue / current.StrainTime;
         }
     }
 }

osu.Game.Rulesets.Osu/Edit/Layers/Selection/Overlays/SliderCircleMask.cs

@@ -56,6 +56,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Layers.Selection.Overlays
         }
 
         // Todo: This is temporary, since the slider circle masks don't do anything special yet. In the future they will handle input.
-        public override bool HandleMouseInput => false;
+        public override bool HandlePositionalInput => false;
     }
 }

osu.Game.Rulesets.Osu/Edit/Layers/Selection/Overlays/SliderMask.cs

@@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Layers.Selection.Overlays
             body.UpdateProgress(0);
         }
 
-        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => body.ReceiveMouseInputAt(screenSpacePos);
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => body.ReceivePositionalInputAt(screenSpacePos);
 
         public override Vector2 SelectionPoint => ToScreenSpace(OriginPosition);
         public override Quad SelectionQuad => body.PathDrawQuad;

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

@@ -4,6 +4,7 @@
 using osu.Framework.Graphics.Cursor;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Rulesets.UI;
 using OpenTK;
 
 namespace osu.Game.Rulesets.Osu.Edit
@@ -15,8 +16,8 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
-        protected override Vector2 PlayfieldArea => Vector2.One;
-
         protected override CursorContainer CreateCursor() => null;
+
+        protected override Playfield CreatePlayfield() => new OsuPlayfield { Size = Vector2.One　};
     }
 }

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

@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
@@ -31,7 +32,7 @@ namespace osu.Game.Rulesets.Osu.Edit
             new HitObjectCompositionTool<Spinner>()
         };
 
-        protected override ScalableContainer CreateLayerContainer() => new ScalableContainer(OsuPlayfield.BASE_SIZE.X) { RelativeSizeAxes = Axes.Both };
+        protected override Container CreateLayerContainer() => new PlayfieldAdjustmentContainer { RelativeSizeAxes = Axes.Both };
 
         public override HitObjectMask CreateMaskFor(DrawableHitObject hitObject)
         {

osu.Game.Rulesets.Osu/Mods/OsuModHardRock.cs

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Game.Rulesets.Mods;
@@ -33,8 +32,9 @@ namespace osu.Game.Rulesets.Osu.Mods
             slider.NestedHitObjects.OfType<SliderTick>().ForEach(h => h.Position = new Vector2(h.Position.X, OsuPlayfield.BASE_SIZE.Y - h.Position.Y));
             slider.NestedHitObjects.OfType<RepeatPoint>().ForEach(h => h.Position = new Vector2(h.Position.X, OsuPlayfield.BASE_SIZE.Y - h.Position.Y));
 
-            var newControlPoints = new List<Vector2>();
-            slider.ControlPoints.ForEach(c => newControlPoints.Add(new Vector2(c.X, -c.Y)));
+            var newControlPoints = new Vector2[slider.ControlPoints.Length];
+            for (int i = 0; i < slider.ControlPoints.Length; i++)
+                newControlPoints[i] = new Vector2(slider.ControlPoints[i].X, -slider.ControlPoints[i].Y);
 
             slider.ControlPoints = newControlPoints;
             slider.Curve?.Calculate(); // Recalculate the slider curve

osu.Game.Rulesets.Osu/Mods/OsuModRelax.cs

@@ -4,7 +4,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using osu.Framework.Input.States;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
@@ -77,7 +76,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                 wasLeft = !wasLeft;
             }
 
-            osuInputManager.HandleCustomInput(new InputState(), state);
+            state.Apply(osuInputManager.CurrentState, osuInputManager);
         }
 
         public void ApplyToRulesetContainer(RulesetContainer<OsuHitObject> rulesetContainer)

osu.Game.Rulesets.Osu/Mods/OsuModTransform.cs

@@ -0,0 +1,53 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    internal class OsuModTransform : Mod, IApplicableToDrawableHitObjects
+    {
+        public override string Name => "Transform";
+        public override string ShortenedName => "TR";
+        public override FontAwesome Icon => FontAwesome.fa_arrows;
+        public override ModType Type => ModType.Fun;
+        public override string Description => "Everything rotates. EVERYTHING.";
+        public override double ScoreMultiplier => 1;
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModWiggle) };
+
+        private float theta;
+
+        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        {
+            foreach (var drawable in drawables)
+            {
+                var hitObject = (OsuHitObject) drawable.HitObject;
+
+                float appearDistance = (float)(hitObject.TimePreempt - hitObject.TimeFadeIn) / 2;
+
+                Vector2 originalPosition = drawable.Position;
+                Vector2 appearOffset = new Vector2((float)Math.Cos(theta), (float)Math.Sin(theta)) * appearDistance;
+
+                //the - 1 and + 1 prevents the hit objects to appear in the wrong position.
+                double appearTime = hitObject.StartTime - hitObject.TimePreempt - 1;
+                double moveDuration = hitObject.TimePreempt + 1;
+
+                using (drawable.BeginAbsoluteSequence(appearTime, true))
+                {
+                    drawable
+                        .MoveToOffset(appearOffset)
+                        .MoveTo(originalPosition, moveDuration, Easing.InOutSine);
+                }
+
+                theta += (float) hitObject.TimeFadeIn / 1000;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs

@@ -0,0 +1,72 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using osu.Framework.Graphics;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Objects;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Mods
+{
+    internal class OsuModWiggle : Mod, IApplicableToDrawableHitObjects
+    {
+        public override string Name => "Wiggle";
+        public override string ShortenedName => "WG";
+        public override FontAwesome Icon => FontAwesome.fa_certificate;
+        public override ModType Type => ModType.Fun;
+        public override string Description => "They just won't stay still...";
+        public override double ScoreMultiplier => 1;
+        public override Type[] IncompatibleMods => new[] { typeof(OsuModTransform) };
+
+        private const int wiggle_duration = 90; // (ms) Higher = fewer wiggles
+        private const int wiggle_strength = 10; // Higher = stronger wiggles
+
+        public void ApplyToDrawableHitObjects(IEnumerable<DrawableHitObject> drawables)
+        {
+            foreach (var drawable in drawables)
+                drawable.ApplyCustomUpdateState += drawableOnApplyCustomUpdateState;
+        }
+
+        private void drawableOnApplyCustomUpdateState(DrawableHitObject drawable, ArmedState state)
+        {
+            var osuObject = (OsuHitObject)drawable.HitObject;
+            Vector2 origin = drawable.Position;
+
+            // Wiggle the repeat points with the slider instead of independently.
+            // Also fixes an issue with repeat points being positioned incorrectly.
+            if (osuObject is RepeatPoint)
+                return;
+
+            Random objRand = new Random((int)osuObject.StartTime);
+
+            // Wiggle all objects during TimePreempt
+            int amountWiggles = (int)osuObject.TimePreempt / wiggle_duration;
+
+            void wiggle()
+            {
+                float nextAngle = (float)(objRand.NextDouble() * 2 * Math.PI);
+                float nextDist = (float)(objRand.NextDouble() * wiggle_strength);
+                drawable.MoveTo(new Vector2((float)(nextDist * Math.Cos(nextAngle) + origin.X), (float)(nextDist * Math.Sin(nextAngle) + origin.Y)), wiggle_duration);
+            }
+
+            for (int i = 0; i < amountWiggles; i++)
+                using (drawable.BeginAbsoluteSequence(osuObject.StartTime - osuObject.TimePreempt + i * wiggle_duration, true))
+                    wiggle();
+
+            // Keep wiggling sliders and spinners for their duration
+            if (!(osuObject is IHasEndTime endTime))
+                return;
+
+            amountWiggles = (int)(endTime.Duration / wiggle_duration);
+
+            for (int i = 0; i < amountWiggles; i++)
+                using (drawable.BeginAbsoluteSequence(osuObject.StartTime + i * wiggle_duration, true))
+                    wiggle();
+        }
+    }
+}

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

@@ -184,6 +184,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public Drawable ProxiedLayer => HeadCircle.ApproachCircle;
 
-        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => Body.ReceiveMouseInputAt(screenSpacePos);
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Body.ReceivePositionalInputAt(screenSpacePos);
     }
 }

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

@@ -12,6 +12,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
     public class CirclePiece : Container, IKeyBindingHandler<OsuAction>
     {
+        // IsHovered is used
+        public override bool HandlePositionalInput => true;
+
         public Func<bool> Hit;
 
         public CirclePiece()

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

@@ -5,11 +5,11 @@ using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.EventArgs;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Objects.Types;
 using OpenTK.Graphics;
 using osu.Game.Skinning;
+using OpenTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
@@ -102,24 +102,24 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             };
         }
 
-        private InputState lastState;
+        private Vector2? lastScreenSpaceMousePosition;
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
-            lastState = state;
-            return base.OnMouseDown(state, args);
+            lastScreenSpaceMousePosition = e.ScreenSpaceMousePosition;
+            return base.OnMouseDown(e);
         }
 
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        protected override bool OnMouseUp(MouseUpEvent e)
         {
-            lastState = state;
-            return base.OnMouseUp(state, args);
+            lastScreenSpaceMousePosition = e.ScreenSpaceMousePosition;
+            return base.OnMouseUp(e);
         }
 
-        protected override bool OnMouseMove(InputState state)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
-            lastState = state;
-            return base.OnMouseMove(state);
+            lastScreenSpaceMousePosition = e.ScreenSpaceMousePosition;
+            return base.OnMouseMove(e);
         }
 
         public override void ClearTransformsAfter(double time, bool propagateChildren = false, string targetMember = null)
@@ -153,10 +153,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
             if (Time.Current < slider.EndTime)
             {
-                // Make sure to use the base version of ReceiveMouseInputAt so that we correctly check the position.
+                // Make sure to use the base version of ReceivePositionalInputAt so that we correctly check the position.
                 Tracking = canCurrentlyTrack
-                           && lastState != null
-                           && ReceiveMouseInputAt(lastState.Mouse.NativeState.Position)
+                           && lastScreenSpaceMousePosition.HasValue
+                           && ReceivePositionalInputAt(lastScreenSpaceMousePosition.Value)
                            && (drawableSlider?.OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false);
             }
         }

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

@@ -8,26 +8,23 @@ using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Lines;
-using osu.Framework.Graphics.Textures;
 using OpenTK.Graphics.ES30;
 using OpenTK.Graphics;
 using osu.Framework.Graphics.Primitives;
 using osu.Game.Rulesets.Objects.Types;
 using OpenTK;
-using SixLabors.ImageSharp;
-using SixLabors.ImageSharp.PixelFormats;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
     public class SliderBody : Container, ISliderProgress
     {
-        private readonly Path path;
+        private readonly SliderPath path;
         private readonly BufferedContainer container;
 
         public float PathWidth
         {
-            get { return path.PathWidth; }
-            set { path.PathWidth = value; }
+            get => path.PathWidth;
+            set => path.PathWidth = value;
         }
 
         /// <summary>
@@ -43,48 +40,40 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         public double? SnakedStart { get; private set; }
         public double? SnakedEnd { get; private set; }
 
-        private Color4 accentColour = Color4.White;
-
         /// <summary>
         /// Used to colour the path.
         /// </summary>
         public Color4 AccentColour
         {
-            get { return accentColour; }
+            get => path.AccentColour;
             set
             {
-                if (accentColour == value)
+                if (path.AccentColour == value)
                     return;
-                accentColour = value;
+                path.AccentColour = value;
 
-                if (LoadState >= LoadState.Ready)
-                    reloadTexture();
+                container.ForceRedraw();
             }
         }
 
-        private Color4 borderColour = Color4.White;
-
         /// <summary>
         /// Used to colour the path border.
         /// </summary>
         public new Color4 BorderColour
         {
-            get { return borderColour; }
+            get => path.BorderColour;
             set
             {
-                if (borderColour == value)
+                if (path.BorderColour == value)
                     return;
-                borderColour = value;
+                path.BorderColour = value;
 
-                if (LoadState >= LoadState.Ready)
-                    reloadTexture();
+                container.ForceRedraw();
             }
         }
 
         public Quad PathDrawQuad => container.ScreenSpaceDrawQuad;
 
-        private int textureWidth => (int)PathWidth * 2;
-
         private Vector2 topLeftOffset;
 
         private readonly Slider slider;
@@ -101,7 +90,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                     CacheDrawnFrameBuffer = true,
                     Children = new Drawable[]
                     {
-                        path = new Path
+                        path = new SliderPath
                         {
                             Blending = BlendingMode.None,
                         },
@@ -112,7 +101,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             container.Attach(RenderbufferInternalFormat.DepthComponent16);
         }
 
-        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => path.ReceiveMouseInputAt(screenSpacePos);
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => path.ReceivePositionalInputAt(screenSpacePos);
 
         public void SetRange(double p0, double p1)
         {
@@ -134,46 +123,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         [BackgroundDependencyLoader]
         private void load()
         {
-            reloadTexture();
             computeSize();
         }
 
-        private void reloadTexture()
-        {
-            var texture = new Texture(textureWidth, 1);
-
-            //initialise background
-            var raw = new Image<Rgba32>(textureWidth, 1);
-
-            const float aa_portion = 0.02f;
-            const float border_portion = 0.128f;
-            const float gradient_portion = 1 - border_portion;
-
-            const float opacity_at_centre = 0.3f;
-            const float opacity_at_edge = 0.8f;
-
-            for (int i = 0; i < textureWidth; i++)
-            {
-                float progress = (float)i / (textureWidth - 1);
-
-                if (progress <= border_portion)
-                {
-                    raw[i, 0] = new Rgba32(BorderColour.R, BorderColour.G, BorderColour.B, Math.Min(progress / aa_portion, 1) * BorderColour.A);
-                }
-                else
-                {
-                    progress -= border_portion;
-                    raw[i, 0] = new Rgba32(AccentColour.R, AccentColour.G, AccentColour.B,
-                        (opacity_at_edge - (opacity_at_edge - opacity_at_centre) * progress / gradient_portion) * AccentColour.A);
-                }
-            }
-
-            texture.SetData(new TextureUpload(raw));
-            path.Texture = texture;
-
-            container.ForceRedraw();
-        }
-
         private void computeSize()
         {
             // Generate the entire curve
@@ -226,5 +178,53 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
             SetRange(start, end);
         }
+
+        private class SliderPath : SmoothPath
+        {
+            private const float border_portion = 0.128f;
+            private const float gradient_portion = 1 - border_portion;
+
+            private const float opacity_at_centre = 0.3f;
+            private const float opacity_at_edge = 0.8f;
+
+            private Color4 borderColour = Color4.White;
+
+            public Color4 BorderColour
+            {
+                get => borderColour;
+                set
+                {
+                    if (borderColour == value)
+                        return;
+                    borderColour = value;
+
+                    InvalidateTexture();
+                }
+            }
+
+            private Color4 accentColour = Color4.White;
+
+            public Color4 AccentColour
+            {
+                get => accentColour;
+                set
+                {
+                    if (accentColour == value)
+                        return;
+                    accentColour = value;
+
+                    InvalidateTexture();
+                }
+            }
+
+            protected override Color4 ColourAt(float position)
+            {
+                if (position <= border_portion)
+                    return BorderColour;
+
+                position -= border_portion;
+                return new Color4(AccentColour.R, AccentColour.G, AccentColour.B, (opacity_at_edge - (opacity_at_edge - opacity_at_centre) * position / gradient_portion) * AccentColour.A);
+            }
+        }
     }
 }

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

@@ -11,9 +11,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
     public class SpinnerBackground : CircularContainer, IHasAccentColour
     {
-        public override bool HandleKeyboardInput => false;
-        public override bool HandleMouseInput => false;
-
         protected Box Disc;
 
         public Color4 AccentColour

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

@@ -4,7 +4,7 @@
 using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics;
 using OpenTK;
 using OpenTK.Graphics;
@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             };
         }
 
-        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => true;
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
         private bool tracking;
         public bool Tracking
@@ -68,10 +68,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             }
         }
 
-        protected override bool OnMouseMove(InputState state)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
-            mousePosition = Parent.ToLocalSpace(state.Mouse.NativeState.Position);
-            return base.OnMouseMove(state);
+            mousePosition = Parent.ToLocalSpace(e.ScreenSpaceMousePosition);
+            return base.OnMouseMove(e);
         }
 
         private Vector2 mousePosition;

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

@@ -52,7 +52,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public SliderCurve Curve { get; } = new SliderCurve();
 
-        public List<Vector2> ControlPoints
+        public Vector2[] ControlPoints
         {
             get { return Curve.ControlPoints; }
             set { Curve.ControlPoints = value; }

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -4,8 +4,7 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using osu.Framework.Input.Bindings;
-using osu.Framework.Input.EventArgs;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu
@@ -36,22 +35,20 @@ namespace osu.Game.Rulesets.Osu
             {
             }
 
-            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args) => AllowUserPresses && base.OnKeyDown(state, args);
-            protected override bool OnKeyUp(InputState state, KeyUpEventArgs args) => AllowUserPresses && base.OnKeyUp(state, args);
-            protected override bool OnJoystickPress(InputState state, JoystickEventArgs args) => AllowUserPresses && base.OnJoystickPress(state, args);
-            protected override bool OnJoystickRelease(InputState state, JoystickEventArgs args) => AllowUserPresses && base.OnJoystickRelease(state, args);
-            protected override bool OnMouseDown(InputState state, MouseDownEventArgs args) => AllowUserPresses && base.OnMouseDown(state, args);
-            protected override bool OnMouseUp(InputState state, MouseUpEventArgs args) => AllowUserPresses && base.OnMouseUp(state, args);
-            protected override bool OnScroll(InputState state) => AllowUserPresses && base.OnScroll(state);
+            protected override bool Handle(UIEvent e)
+            {
+                if (!AllowUserPresses) return false;
+                return base.Handle(e);
+            }
         }
     }
 
     public enum OsuAction
     {
-        [Description("Left Button")]
+        [Description("Left button")]
         LeftButton,
 
-        [Description("Right Button")]
+        [Description("Right button")]
         RightButton
     }
 }

osu.Game.Rulesets.Osu/OsuRuleset.cs

@@ -117,6 +117,11 @@ namespace osu.Game.Rulesets.Osu
                         new OsuModRelax(),
                         new OsuModAutopilot(),
                     };
+                case ModType.Fun:
+                    return new Mod[] {
+                        new OsuModTransform(),
+                        new OsuModWiggle(),
+                    };
                 default:
                     return new Mod[] { };
             }

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

@@ -12,7 +12,7 @@ using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shaders;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.Timing;
 using OpenTK;
 using OpenTK.Graphics;
@@ -76,7 +76,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             }
         }
 
-        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => true;
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => true;
 
         [BackgroundDependencyLoader]
         private void load(ShaderManager shaders, TextureStore textures)
@@ -117,15 +117,15 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             timeOffset = Time.Current;
         }
 
-        protected override bool OnMouseMove(InputState state)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
-            Vector2 pos = state.Mouse.NativeState.Position;
+            Vector2 pos = e.ScreenSpaceMousePosition;
 
             if (lastPosition == null)
             {
                 lastPosition = pos;
                 resampler.AddPosition(lastPosition.Value);
-                return base.OnMouseMove(state);
+                return base.OnMouseMove(e);
             }
 
             foreach (Vector2 pos2 in resampler.AddPosition(pos))
@@ -147,7 +147,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 }
             }
 
-            return base.OnMouseMove(state);
+            return base.OnMouseMove(e);
         }
 
         private void addPosition(Vector2 pos)

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

@@ -72,7 +72,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
             return false;
         }
 
-        public override bool HandleMouseInput => true; // OverlayContainer will set this false when we go hidden, but we always want to receive input.
+        public override bool HandlePositionalInput => true; // OverlayContainer will set this false when we go hidden, but we always want to receive input.
 
         protected override void PopIn()
         {

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

@@ -23,29 +23,35 @@ namespace osu.Game.Rulesets.Osu.UI
         public static readonly Vector2 BASE_SIZE = new Vector2(512, 384);
 
         public OsuPlayfield()
-            : base(BASE_SIZE.X)
         {
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
 
-            AddRange(new Drawable[]
+            Size = new Vector2(0.75f);
+
+            InternalChild = new PlayfieldAdjustmentContainer
             {
-                connectionLayer = new FollowPointRenderer
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
                 {
-                    RelativeSizeAxes = Axes.Both,
-                    Depth = 2,
-                },
-                judgementLayer = new JudgementContainer<DrawableOsuJudgement>
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Depth = 1,
-                },
-                approachCircles = new Container
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Depth = -1,
-                },
-            });
+                    connectionLayer = new FollowPointRenderer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Depth = 2,
+                    },
+                    judgementLayer = new JudgementContainer<DrawableOsuJudgement>
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Depth = 1,
+                    },
+                    HitObjectContainer,
+                    approachCircles = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Depth = -1,
+                    },
+                }
+            };
         }
 
         public override void Add(DrawableHitObject h)
@@ -72,7 +78,8 @@ namespace osu.Game.Rulesets.Osu.UI
             DrawableOsuJudgement explosion = new DrawableOsuJudgement(result, judgedObject)
             {
                 Origin = Anchor.Centre,
-                Position = ((OsuHitObject)judgedObject.HitObject).StackedEndPosition
+                Position = ((OsuHitObject)judgedObject.HitObject).StackedEndPosition,
+                Scale = new Vector2(((OsuHitObject)judgedObject.HitObject).Scale * 1.65f)
             };
 
             judgementLayer.Add(explosion);

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

@@ -4,7 +4,6 @@
 using System.Linq;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Input;
-using OpenTK;
 using osu.Game.Beatmaps;
 using osu.Game.Input.Handlers;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -58,12 +57,6 @@ namespace osu.Game.Rulesets.Osu.UI
             }
         }
 
-        protected override Vector2 GetAspectAdjustedSize()
-        {
-            var aspectSize = DrawSize.X * 0.75f < DrawSize.Y ? new Vector2(DrawSize.X, DrawSize.X * 0.75f) : new Vector2(DrawSize.Y * 4f / 3f, DrawSize.Y);
-            return new Vector2(aspectSize.X / DrawSize.X, aspectSize.Y / DrawSize.Y);
-        }
-
         protected override CursorContainer CreateCursor() => new GameplayCursor();
     }
 }

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

@@ -0,0 +1,42 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.UI
+{
+    public class PlayfieldAdjustmentContainer : Container
+    {
+        protected override Container<Drawable> Content => content;
+        private readonly Container content;
+
+        public PlayfieldAdjustmentContainer()
+        {
+            InternalChild = new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Both,
+                FillMode = FillMode.Fit,
+                FillAspectRatio = 4f / 3,
+                Child = content = new ScalingContainer { RelativeSizeAxes = Axes.Both }
+            };
+        }
+
+        /// <summary>
+        /// A <see cref="Container"/> which scales its content relative to a target width.
+        /// </summary>
+        private class ScalingContainer : Container
+        {
+            protected override void Update()
+            {
+                base.Update();
+
+                Scale = new Vector2(Parent.ChildSize.X / OsuPlayfield.BASE_SIZE.X);
+                Size = Vector2.Divide(Vector2.One, Scale);
+            }
+        }
+    }
+}

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

@@ -2,9 +2,10 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
-    <PackageReference Include="NUnit" Version="3.10.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="NUnit" Version="3.11.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.10.0" />
+    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

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

@@ -24,6 +24,8 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
         private bool validActionPressed;
 
+        private bool pressHandledThisFrame;
+
         protected DrawableHit(Hit hit)
             : base(hit)
         {
@@ -51,6 +53,9 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
         public override bool OnPressed(TaikoAction action)
         {
+            if (pressHandledThisFrame)
+                return true;
+
             if (Judged)
                 return false;
 
@@ -62,6 +67,10 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             if (IsHit)
                 HitAction = action;
 
+            // Regardless of whether we've hit or not, any secondary key presses in the same frame should be discarded
+            // E.g. hitting a non-strong centre as a strong should not fall through and perform a hit on the next note
+            pressHandledThisFrame = true;
+
             return result;
         }
 
@@ -76,6 +85,10 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         {
             base.Update();
 
+            // The input manager processes all input prior to us updating, so this is the perfect time
+            // for us to remove the extra press blocking, before input is handled in the next frame
+            pressHandledThisFrame = false;
+
             Size = BaseSize * Parent.RelativeChildSize;
         }
 

osu.Game.Rulesets.Taiko/TaikoInputManager.cs

@@ -17,13 +17,13 @@ namespace osu.Game.Rulesets.Taiko
 
     public enum TaikoAction
     {
-        [Description("Left (Rim)")]
+        [Description("Left (rim)")]
         LeftRim,
-        [Description("Left (Centre)")]
+        [Description("Left (centre)")]
         LeftCentre,
-        [Description("Right (Centre)")]
+        [Description("Right (centre)")]
         RightCentre,
-        [Description("Right (Rim)")]
+        [Description("Right (rim)")]
         RightRim
     }
 }

osu.Game.Rulesets.Taiko/UI/DrawableTaikoJudgement.cs

@@ -31,10 +31,10 @@ namespace osu.Game.Rulesets.Taiko.UI
             switch (Result.Type)
             {
                 case HitResult.Good:
-                    Colour = colours.GreenLight;
+                    JudgementBody.Colour = colours.GreenLight;
                     break;
                 case HitResult.Great:
-                    Colour = colours.BlueLight;
+                    JudgementBody.Colour = colours.BlueLight;
                     break;
             }
         }

osu.Game.Rulesets.Taiko/UI/PlayfieldAdjustmentContainer.cs

@@ -0,0 +1,22 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics.Containers;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Taiko.UI
+{
+    public class PlayfieldAdjustmentContainer : Container
+    {
+        private const float default_relative_height = TaikoPlayfield.DEFAULT_HEIGHT / 768;
+        private const float default_aspect = 16f / 9f;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            float aspectAdjust = MathHelper.Clamp(Parent.ChildSize.X / Parent.ChildSize.Y, 0.4f, 4) / default_aspect;
+            Size = new Vector2(1, default_relative_height * aspectAdjust);
+        }
+    }
+}

osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs

@@ -1,23 +1,24 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Taiko.Objects;
-using OpenTK;
-using OpenTK.Graphics;
-using osu.Game.Rulesets.Taiko.Judgements;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Extensions.Color4Extensions;
 using System.Linq;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Taiko.Objects.Drawables;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
+using osu.Game.Rulesets.Taiko.Judgements;
+using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
@@ -40,13 +41,12 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         protected override bool UserScrollSpeedAdjustment => false;
 
+        protected override SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Overlapping;
+
         private readonly Container<HitExplosion> hitExplosionContainer;
         private readonly Container<KiaiHitExplosion> kiaiExplosionContainer;
         private readonly JudgementContainer<DrawableTaikoJudgement> judgementContainer;
 
-        protected override Container<Drawable> Content => content;
-        private readonly Container content;
-
         private readonly Container topLevelHitContainer;
 
         private readonly Container barlineContainer;
@@ -61,140 +61,147 @@ namespace osu.Game.Rulesets.Taiko.UI
         {
             Direction.Value = ScrollingDirection.Left;
 
-            AddRangeInternal(new Drawable[]
+            InternalChild = new PlayfieldAdjustmentContainer
             {
-                backgroundContainer = new Container
+                Anchor = Anchor.CentreLeft,
+                Origin = Anchor.CentreLeft,
+                RelativeSizeAxes = Axes.Both,
+                Children = new Drawable[]
                 {
-                    Name = "Transparent playfield background",
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    EdgeEffect = new EdgeEffectParameters
+                    backgroundContainer = new Container
                     {
-                        Type = EdgeEffectType.Shadow,
-                        Colour = Color4.Black.Opacity(0.2f),
-                        Radius = 5,
-                    },
-                    Children = new Drawable[]
-                    {
-                        background = new Box
+                        Name = "Transparent playfield background",
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        EdgeEffect = new EdgeEffectParameters
                         {
-                            RelativeSizeAxes = Axes.Both,
-                            Alpha = 0.6f
+                            Type = EdgeEffectType.Shadow,
+                            Colour = Color4.Black.Opacity(0.2f),
+                            Radius = 5,
                         },
-                    }
-                },
-                new Container
-                {
-                    Name = "Right area",
-                    RelativeSizeAxes = Axes.Both,
-                    Padding = new MarginPadding { Left = left_area_size },
-                    Children = new Drawable[]
-                    {
-                        new Container
+                        Children = new Drawable[]
                         {
-                            Name = "Masked elements before hit objects",
-                            RelativeSizeAxes = Axes.Both,
-                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                            Masking = true,
-                            Children = new Drawable[]
+                            background = new Box
                             {
-                                hitExplosionContainer = new Container<HitExplosion>
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    FillMode = FillMode.Fit,
-                                    Blending = BlendingMode.Additive,
-                                },
-                                new HitTarget
-                                {
-                                    Anchor = Anchor.CentreLeft,
-                                    Origin = Anchor.Centre,
-                                    RelativeSizeAxes = Axes.Both,
-                                    FillMode = FillMode.Fit
-                                }
-                            }
-                        },
-                        barlineContainer = new Container
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET }
-                        },
-                        content = new Container
-                        {
-                            Name = "Hit objects",
-                            RelativeSizeAxes = Axes.Both,
-                            Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                            Masking = true
-                        },
-                        kiaiExplosionContainer = new Container<KiaiHitExplosion>
-                        {
-                            Name = "Kiai hit explosions",
-                            RelativeSizeAxes = Axes.Both,
-                            FillMode = FillMode.Fit,
-                            Margin = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                            Blending = BlendingMode.Additive
-                        },
-                        judgementContainer = new JudgementContainer<DrawableTaikoJudgement>
-                        {
-                            Name = "Judgements",
-                            RelativeSizeAxes = Axes.Y,
-                            Margin = new MarginPadding { Left = HIT_TARGET_OFFSET },
-                            Blending = BlendingMode.Additive
-                        },
-                    }
-                },
-                overlayBackgroundContainer = new Container
-                {
-                    Name = "Left overlay",
-                    RelativeSizeAxes = Axes.Y,
-                    Size = new Vector2(left_area_size, 1),
-                    Children = new Drawable[]
-                    {
-                        overlayBackground = new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                        },
-                        new InputDrum(controlPoints)
-                        {
-                            Anchor = Anchor.CentreRight,
-                            Origin = Anchor.CentreRight,
-                            Scale = new Vector2(0.9f),
-                            Margin = new MarginPadding { Right = 20 }
-                        },
-                        new Box
-                        {
-                            Anchor = Anchor.TopRight,
-                            RelativeSizeAxes = Axes.Y,
-                            Width = 10,
-                            Colour = Framework.Graphics.Colour.ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.6f), Color4.Black.Opacity(0)),
-                        },
-                    }
-                },
-                new Container
-                {
-                    Name = "Border",
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    MaskingSmoothness = 0,
-                    BorderThickness = 2,
-                    AlwaysPresent = true,
-                    Children = new[]
-                    {
-                        new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Alpha = 0,
-                            AlwaysPresent = true
+                                RelativeSizeAxes = Axes.Both,
+                                Alpha = 0.6f
+                            },
                         }
+                    },
+                    new Container
+                    {
+                        Name = "Right area",
+                        RelativeSizeAxes = Axes.Both,
+                        Padding = new MarginPadding { Left = left_area_size },
+                        Children = new Drawable[]
+                        {
+                            new Container
+                            {
+                                Name = "Masked elements before hit objects",
+                                RelativeSizeAxes = Axes.Both,
+                                Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
+                                Masking = true,
+                                Children = new Drawable[]
+                                {
+                                    hitExplosionContainer = new Container<HitExplosion>
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        FillMode = FillMode.Fit,
+                                        Blending = BlendingMode.Additive,
+                                    },
+                                    new HitTarget
+                                    {
+                                        Anchor = Anchor.CentreLeft,
+                                        Origin = Anchor.Centre,
+                                        RelativeSizeAxes = Axes.Both,
+                                        FillMode = FillMode.Fit
+                                    }
+                                }
+                            },
+                            barlineContainer = new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Padding = new MarginPadding { Left = HIT_TARGET_OFFSET }
+                            },
+                            new Container
+                            {
+                                Name = "Hit objects",
+                                RelativeSizeAxes = Axes.Both,
+                                Padding = new MarginPadding { Left = HIT_TARGET_OFFSET },
+                                Masking = true,
+                                Child = HitObjectContainer
+                            },
+                            kiaiExplosionContainer = new Container<KiaiHitExplosion>
+                            {
+                                Name = "Kiai hit explosions",
+                                RelativeSizeAxes = Axes.Both,
+                                FillMode = FillMode.Fit,
+                                Margin = new MarginPadding { Left = HIT_TARGET_OFFSET },
+                                Blending = BlendingMode.Additive
+                            },
+                            judgementContainer = new JudgementContainer<DrawableTaikoJudgement>
+                            {
+                                Name = "Judgements",
+                                RelativeSizeAxes = Axes.Y,
+                                Margin = new MarginPadding { Left = HIT_TARGET_OFFSET },
+                                Blending = BlendingMode.Additive
+                            },
+                        }
+                    },
+                    overlayBackgroundContainer = new Container
+                    {
+                        Name = "Left overlay",
+                        RelativeSizeAxes = Axes.Y,
+                        Size = new Vector2(left_area_size, 1),
+                        Children = new Drawable[]
+                        {
+                            overlayBackground = new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                            new InputDrum(controlPoints)
+                            {
+                                Anchor = Anchor.CentreRight,
+                                Origin = Anchor.CentreRight,
+                                Scale = new Vector2(0.9f),
+                                Margin = new MarginPadding { Right = 20 }
+                            },
+                            new Box
+                            {
+                                Anchor = Anchor.TopRight,
+                                RelativeSizeAxes = Axes.Y,
+                                Width = 10,
+                                Colour = Framework.Graphics.Colour.ColourInfo.GradientHorizontal(Color4.Black.Opacity(0.6f), Color4.Black.Opacity(0)),
+                            },
+                        }
+                    },
+                    new Container
+                    {
+                        Name = "Border",
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        MaskingSmoothness = 0,
+                        BorderThickness = 2,
+                        AlwaysPresent = true,
+                        Children = new[]
+                        {
+                            new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Alpha = 0,
+                                AlwaysPresent = true
+                            }
+                        }
+                    },
+                    topLevelHitContainer = new Container
+                    {
+                        Name = "Top level hit objects",
+                        RelativeSizeAxes = Axes.Both,
                     }
-                },
-                topLevelHitContainer = new Container
-                {
-                    Name = "Top level hit objects",
-                    RelativeSizeAxes = Axes.Both,
                 }
-            });
+            };
 
-            VisibleTimeRange.Value = 6000;
+            VisibleTimeRange.Value = 7000;
         }
 
         [BackgroundDependencyLoader]

osu.Game.Rulesets.Taiko/UI/TaikoRulesetContainer.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Allocation;
-using osu.Framework.Graphics;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
@@ -13,7 +12,6 @@ using osu.Game.Rulesets.Taiko.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.Taiko.Replays;
-using OpenTK;
 using System.Linq;
 using osu.Framework.Input;
 using osu.Game.Input.Handlers;
@@ -74,27 +72,11 @@ namespace osu.Game.Rulesets.Taiko.UI
             }
         }
 
-        protected override Vector2 GetAspectAdjustedSize()
-        {
-            const float default_relative_height = TaikoPlayfield.DEFAULT_HEIGHT / 768;
-            const float default_aspect = 16f / 9f;
-
-            float aspectAdjust = MathHelper.Clamp(DrawWidth / DrawHeight, 0.4f, 4) / default_aspect;
-
-            return new Vector2(1, default_relative_height * aspectAdjust);
-        }
-
-        protected override Vector2 PlayfieldArea => Vector2.One;
-
         public override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor(this);
 
         public override PassThroughInputManager CreateInputManager() => new TaikoInputManager(Ruleset.RulesetInfo);
 
-        protected override Playfield CreatePlayfield() => new TaikoPlayfield(Beatmap.ControlPointInfo)
-        {
-            Anchor = Anchor.CentreLeft,
-            Origin = Anchor.CentreLeft
-        };
+        protected override Playfield CreatePlayfield() => new TaikoPlayfield(Beatmap.ControlPointInfo);
 
         protected override DrawableHitObject<TaikoHitObject> GetVisualRepresentation(TaikoHitObject h)
         {

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

@@ -165,7 +165,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
         }
 
         [Test]
-        public void TestDecodeBeatmapColors()
+        public void TestDecodeBeatmapColours()
         {
             var decoder = new LegacySkinDecoder();
             using (var resStream = Resource.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
@@ -181,6 +181,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
                     new Color4(128, 255, 128, 255),
                     new Color4(255, 187, 255, 255),
                     new Color4(255, 177, 140, 255),
+                    new Color4(100, 100, 100, 100),
                 };
                 Assert.AreEqual(expectedColors.Length, comboColors.Count);
                 for (int i = 0; i < expectedColors.Length; i++)

osu.Game.Tests/Resources/Soleily - Renatus (Gamu) [Insane].osu

@@ -101,6 +101,7 @@ Combo3 : 128,255,255
 Combo4 : 128,255,128
 Combo5 : 255,187,255
 Combo6 : 255,177,140
+Combo7 : 100,100,100,100
 
 [HitObjects]
 192,168,956,6,0,P|184:128|200:80,1,90,4|0,1:2|0:0,0:0:0:0:

osu.Game.Tests/Visual/TestCaseCursors.cs

@@ -7,7 +7,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Framework.MathUtils;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Graphics.Sprites;
@@ -184,7 +184,7 @@ namespace osu.Game.Tests.Visual
         /// </summary>
         /// <param name="cursorContainer">The cursor to check.</param>
         private bool checkAtMouse(CursorContainer cursorContainer)
-            => Precision.AlmostEquals(InputManager.CurrentState.Mouse.NativeState.Position, cursorContainer.ToScreenSpace(cursorContainer.ActiveCursor.DrawPosition));
+            => Precision.AlmostEquals(InputManager.CurrentState.Mouse.Position, cursorContainer.ToScreenSpace(cursorContainer.ActiveCursor.DrawPosition));
 
         private class CustomCursorBox : Container, IProvideCursor
         {
@@ -193,7 +193,7 @@ namespace osu.Game.Tests.Visual
             public CursorContainer Cursor { get; }
             public bool ProvidingUserCursor { get; }
 
-            public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => base.ReceiveMouseInputAt(screenSpacePos) || SmoothTransition && !ProvidingUserCursor;
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => base.ReceivePositionalInputAt(screenSpacePos) || SmoothTransition && !ProvidingUserCursor;
 
             private readonly Box background;
 
@@ -224,16 +224,16 @@ namespace osu.Game.Tests.Visual
                 };
             }
 
-            protected override bool OnHover(InputState state)
+            protected override bool OnHover(HoverEvent e)
             {
                 background.FadeTo(0.4f, 250, Easing.OutQuint);
                 return false;
             }
 
-            protected override void OnHoverLost(InputState state)
+            protected override void OnHoverLost(HoverLostEvent e)
             {
                 background.FadeTo(0.1f, 250);
-                base.OnHoverLost(state);
+                base.OnHoverLost(e);
             }
         }
 

osu.Game.Tests/Visual/TestCaseGameplayMenuOverlay.cs

@@ -8,14 +8,14 @@ using System.Linq;
 using OpenTK.Input;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.EventArgs;
 using osu.Framework.Logging;
 using osu.Game.Screens.Play;
+using OpenTK;
 
 namespace osu.Game.Tests.Visual
 {
     [Description("player pause/fail screens")]
-    public class TestCaseGameplayMenuOverlay : OsuTestCase
+    public class TestCaseGameplayMenuOverlay : ManualInputManagerTestCase
     {
         public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(FailOverlay), typeof(PauseContainer) };
 
@@ -73,12 +73,18 @@ namespace osu.Game.Tests.Visual
         {
             AddStep("Show overlay", () => failOverlay.Show());
 
-            AddStep("Hover first button", () => failOverlay.Buttons.First().TriggerOnMouseMove(null));
+            AddStep("Hover first button", () => InputManager.MoveMouseTo(failOverlay.Buttons.First()));
             AddStep("Hide overlay", () => failOverlay.Hide());
 
             AddAssert("Overlay state is reset", () => !failOverlay.Buttons.Any(b => b.Selected));
         }
 
+        private void press(Key key)
+        {
+            InputManager.PressKey(key);
+            InputManager.ReleaseKey(key);
+        }
+
         /// <summary>
         /// Tests that pressing enter after an overlay shows doesn't trigger an event because a selection hasn't occurred.
         /// </summary>
@@ -86,7 +92,7 @@ namespace osu.Game.Tests.Visual
         {
             AddStep("Show overlay", () => pauseOverlay.Show());
 
-            AddStep("Press enter", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Enter }));
+            AddStep("Press enter", () => press(Key.Enter));
             AddAssert("Overlay still open", () => pauseOverlay.State == Visibility.Visible);
 
             AddStep("Hide overlay", () => pauseOverlay.Hide());
@@ -99,7 +105,7 @@ namespace osu.Game.Tests.Visual
         {
             AddStep("Show overlay", () => pauseOverlay.Show());
 
-            AddStep("Up arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddStep("Up arrow", () => press(Key.Up));
             AddAssert("Last button selected", () => pauseOverlay.Buttons.Last().Selected);
 
             AddStep("Hide overlay", () => pauseOverlay.Hide());
@@ -112,7 +118,7 @@ namespace osu.Game.Tests.Visual
         {
             AddStep("Show overlay", () => pauseOverlay.Show());
 
-            AddStep("Down arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddStep("Down arrow", () => press(Key.Down));
             AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected);
 
             AddStep("Hide overlay", () => pauseOverlay.Hide());
@@ -125,11 +131,11 @@ namespace osu.Game.Tests.Visual
         {
             AddStep("Show overlay", () => failOverlay.Show());
 
-            AddStep("Up arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddStep("Up arrow", () => press(Key.Up));
             AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
-            AddStep("Up arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddStep("Up arrow", () => press(Key.Up));
             AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
-            AddStep("Up arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddStep("Up arrow", () => press(Key.Up));
             AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
 
             AddStep("Hide overlay", () => failOverlay.Hide());
@@ -142,11 +148,11 @@ namespace osu.Game.Tests.Visual
         {
             AddStep("Show overlay", () => failOverlay.Show());
 
-            AddStep("Down arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddStep("Down arrow", () => press(Key.Down));
             AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
-            AddStep("Down arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddStep("Down arrow", () => press(Key.Down));
             AddAssert("Last button selected", () => failOverlay.Buttons.Last().Selected);
-            AddStep("Down arrow", () => failOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddStep("Down arrow", () => press(Key.Down));
             AddAssert("First button selected", () => failOverlay.Buttons.First().Selected);
 
             AddStep("Hide overlay", () => failOverlay.Hide());
@@ -161,8 +167,8 @@ namespace osu.Game.Tests.Visual
 
             var secondButton = pauseOverlay.Buttons.Skip(1).First();
 
-            AddStep("Down arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
-            AddStep("Hover second button", () => secondButton.TriggerOnMouseMove(null));
+            AddStep("Down arrow", () => press(Key.Down));
+            AddStep("Hover second button", () => InputManager.MoveMouseTo(secondButton));
             AddAssert("First button not selected", () => !pauseOverlay.Buttons.First().Selected);
             AddAssert("Second button selected", () => secondButton.Selected);
 
@@ -174,12 +180,16 @@ namespace osu.Game.Tests.Visual
         /// </summary>
         private void testKeySelectionAfterMouseSelection()
         {
-            AddStep("Show overlay", () => pauseOverlay.Show());
+            AddStep("Show overlay", () =>
+            {
+                pauseOverlay.Show();
+                InputManager.MoveMouseTo(Vector2.Zero);
+            });
 
             var secondButton = pauseOverlay.Buttons.Skip(1).First();
 
-            AddStep("Hover second button", () => secondButton.TriggerOnMouseMove(null));
-            AddStep("Up arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Up }));
+            AddStep("Hover second button", () => InputManager.MoveMouseTo(secondButton));
+            AddStep("Up arrow", () => press(Key.Up));
             AddAssert("Second button not selected", () => !secondButton.Selected);
             AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected);
 
@@ -195,9 +205,9 @@ namespace osu.Game.Tests.Visual
 
             var secondButton = pauseOverlay.Buttons.Skip(1).First();
 
-            AddStep("Hover second button", () => secondButton.TriggerOnMouseMove(null));
-            AddStep("Unhover second button", () => secondButton.TriggerOnHoverLost(null));
-            AddStep("Down arrow", () => pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down }));
+            AddStep("Hover second button", () => InputManager.MoveMouseTo(secondButton));
+            AddStep("Unhover second button", () => InputManager.MoveMouseTo(Vector2.Zero));
+            AddStep("Down arrow", () => press(Key.Down));
             AddAssert("First button selected", () => pauseOverlay.Buttons.First().Selected); // Initial state condition
 
             AddStep("Hide overlay", () => pauseOverlay.Hide());
@@ -218,7 +228,7 @@ namespace osu.Game.Tests.Visual
                 var lastAction = pauseOverlay.OnRetry;
                 pauseOverlay.OnRetry = () => triggered = true;
 
-                retryButton.TriggerOnClick();
+                retryButton.Click();
                 pauseOverlay.OnRetry = lastAction;
             });
 
@@ -235,23 +245,28 @@ namespace osu.Game.Tests.Visual
 
             AddStep("Select second button", () =>
             {
-                pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down });
-                pauseOverlay.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Down });
+                press(Key.Down);
+                press(Key.Down);
             });
 
-            var retryButton = pauseOverlay.Buttons.Skip(1).First();
-
             bool triggered = false;
+            Action lastAction = null;
             AddStep("Press enter", () =>
             {
-                var lastAction = pauseOverlay.OnRetry;
+                lastAction = pauseOverlay.OnRetry;
                 pauseOverlay.OnRetry = () => triggered = true;
-
-                retryButton.TriggerOnKeyDown(null, new KeyDownEventArgs { Key = Key.Enter });
-                pauseOverlay.OnRetry = lastAction;
+                press(Key.Enter);
             });
 
-            AddAssert("Action was triggered", () => triggered);
+            AddAssert("Action was triggered", () =>
+            {
+                if (lastAction != null)
+                {
+                    pauseOverlay.OnRetry = lastAction;
+                    lastAction = null;
+                }
+                return triggered;
+            });
             AddAssert("Overlay is closed", () => pauseOverlay.State == Visibility.Hidden);
         }
     }

osu.Game.Tests/Visual/TestCaseHitObjectComposer.cs

@@ -44,7 +44,7 @@ namespace osu.Game.Tests.Visual
                     new Slider
                     {
                         Position = new Vector2(128, 256),
-                        ControlPoints = new List<Vector2>
+                        ControlPoints = new[]
                         {
                             Vector2.Zero,
                             new Vector2(216, 0),

osu.Game.Tests/Visual/TestCaseKeyCounter.cs

@@ -1,32 +1,45 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics;
 using osu.Framework.MathUtils;
+using osu.Framework.Timing;
 using osu.Game.Screens.Play;
 using OpenTK.Input;
 
 namespace osu.Game.Tests.Visual
 {
     [TestFixture]
-    public class TestCaseKeyCounter : OsuTestCase
+    public class TestCaseKeyCounter : ManualInputManagerTestCase
     {
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(KeyCounterKeyboard),
+            typeof(KeyCounterMouse),
+            typeof(KeyCounterCollection)
+        };
+
         public TestCaseKeyCounter()
         {
+            KeyCounterKeyboard rewindTestKeyCounterKeyboard;
             KeyCounterCollection kc = new KeyCounterCollection
             {
                 Origin = Anchor.Centre,
                 Anchor = Anchor.Centre,
                 Children = new KeyCounter[]
                 {
-                    new KeyCounterKeyboard(Key.Z),
+                    rewindTestKeyCounterKeyboard = new KeyCounterKeyboard(Key.X),
                     new KeyCounterKeyboard(Key.X),
                     new KeyCounterMouse(MouseButton.Left),
                     new KeyCounterMouse(MouseButton.Right),
                 },
             };
 
+
             AddStep("Add random", () =>
             {
                 Key key = (Key)((int)Key.A + RNG.Next(26));
@@ -34,7 +47,57 @@ namespace osu.Game.Tests.Visual
             });
             AddSliderStep("Fade time", 0, 200, 50, v => kc.FadeTime = v);
 
+            Key testKey = ((KeyCounterKeyboard)kc.Children.First()).Key;
+            double time1 = 0;
+
+            AddStep($"Press {testKey} key", () =>
+            {
+                InputManager.PressKey(testKey);
+                InputManager.ReleaseKey(testKey);
+            });
+
+            AddAssert($"Check {testKey} counter after keypress", () => rewindTestKeyCounterKeyboard.CountPresses == 1);
+
+            AddStep($"Press {testKey} key", () =>
+            {
+                InputManager.PressKey(testKey);
+                InputManager.ReleaseKey(testKey);
+                time1 = Clock.CurrentTime;
+            });
+
+            AddAssert($"Check {testKey} counter after keypress", () => rewindTestKeyCounterKeyboard.CountPresses == 2);
+
+            IFrameBasedClock oldClock = null;
+
+            AddStep($"Rewind {testKey} counter once", () =>
+            {
+                oldClock = rewindTestKeyCounterKeyboard.Clock;
+                rewindTestKeyCounterKeyboard.Clock = new FramedOffsetClock(new FixedClock(time1 - 10));
+            });
+
+            AddAssert($"Check {testKey} counter after rewind", () => rewindTestKeyCounterKeyboard.CountPresses == 1);
+
+            AddStep($"Rewind {testKey} counter to zero", () => rewindTestKeyCounterKeyboard.Clock = new FramedOffsetClock(new FixedClock(0)));
+
+            AddAssert($"Check {testKey} counter after rewind", () => rewindTestKeyCounterKeyboard.CountPresses == 0);
+
+            AddStep("Restore clock", () => rewindTestKeyCounterKeyboard.Clock = oldClock);
+
             Add(kc);
         }
+
+        private class FixedClock : IClock
+        {
+            private readonly double time;
+
+            public FixedClock(double time)
+            {
+                this.time = time;
+            }
+
+            public double CurrentTime => time;
+            public double Rate => 1;
+            public bool IsRunning => false;
+        }
     }
 }

osu.Game.Tests/Visual/TestCaseScrollingHitObjects.cs

@@ -121,14 +121,21 @@ namespace osu.Game.Tests.Visual
                 Direction = direction;
 
                 Padding = new MarginPadding(2);
-                Content.Masking = true;
 
-                AddInternal(new Box
+                InternalChildren = new Drawable[]
                 {
-                    RelativeSizeAxes = Axes.Both,
-                    Alpha = 0.5f,
-                    Depth = float.MaxValue
-                });
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0.5f,
+                    },
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        Child = HitObjectContainer
+                    }
+                };
             }
         }
 

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

@@ -2,9 +2,11 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.8.0" />
-    <PackageReference Include="NUnit" Version="3.10.1" />
+    <PackageReference Include="DeepEqual" Version="1.6.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="NUnit" Version="3.11.0" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.10.0" />
+    <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

osu.Game.props

@@ -1,7 +1,7 @@
 <!-- Contains required properties for osu!framework projects. -->
 <Project>
   <PropertyGroup Label="C#">
-    <LangVersion>7</LangVersion>
+    <LangVersion>7.2</LangVersion>
   </PropertyGroup>
   <PropertyGroup>
     <ApplicationManifest>..\app.manifest</ApplicationManifest>

osu.Game/Beatmaps/Beatmap.cs

@@ -48,7 +48,7 @@ namespace osu.Game.Beatmaps
         [JsonConverter(typeof(TypedListConverter<HitObject>))]
         public List<T> HitObjects = new List<T>();
 
-        IEnumerable<HitObject> IBeatmap.HitObjects => HitObjects;
+        IReadOnlyList<HitObject> IBeatmap.HitObjects => HitObjects;
 
         public virtual IEnumerable<BeatmapStatistic> GetStatistics() => Enumerable.Empty<BeatmapStatistic>();
 

osu.Game/Beatmaps/BeatmapConverter.cs

@@ -55,39 +55,40 @@ namespace osu.Game.Beatmaps
 
             beatmap.BeatmapInfo = original.BeatmapInfo;
             beatmap.ControlPointInfo = original.ControlPointInfo;
-            beatmap.HitObjects = original.HitObjects.SelectMany(h => convert(h, original)).ToList();
+            beatmap.HitObjects = convertHitObjects(original.HitObjects, original);
             beatmap.Breaks = original.Breaks;
 
             return beatmap;
         }
 
-        /// <summary>
-        /// Converts a hit object.
-        /// </summary>
-        /// <param name="original">The hit object to convert.</param>
-        /// <param name="beatmap">The un-converted Beatmap.</param>
-        /// <returns>The converted hit object.</returns>
-        private IEnumerable<T> convert(HitObject original, IBeatmap beatmap)
+        private List<T> convertHitObjects(IReadOnlyList<HitObject> hitObjects, IBeatmap beatmap)
         {
-            // Check if the hitobject is already the converted type
-            T tObject = original as T;
-            if (tObject != null)
-            {
-                yield return tObject;
-                yield break;
-            }
+            var result = new List<T>(hitObjects.Count);
 
-            var converted = ConvertHitObject(original, beatmap).ToList();
-            ObjectConverted?.Invoke(original, converted);
-
-            // Convert the hit object
-            foreach (var obj in converted)
+            foreach (var obj in hitObjects)
             {
-                if (obj == null)
+                if (obj is T tObj)
+                {
+                    result.Add(tObj);
                     continue;
+                }
 
-                yield return obj;
+                var converted = ConvertHitObject(obj, beatmap);
+
+                if (ObjectConverted != null)
+                {
+                    converted = converted.ToList();
+                    ObjectConverted.Invoke(obj, converted);
+                }
+
+                foreach (var c in converted)
+                {
+                    if (c != null)
+                        result.Add(c);
+                }
             }
+
+            return result;
         }
 
         /// <summary>

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -27,13 +27,15 @@ namespace osu.Game.Beatmaps
         [JsonProperty("id")]
         public int? OnlineBeatmapID
         {
-            get { return onlineBeatmapID; }
-            set { onlineBeatmapID = value > 0 ? value : null; }
+            get => onlineBeatmapID;
+            set => onlineBeatmapID = value > 0 ? value : null;
         }
 
         [JsonIgnore]
         public int BeatmapSetInfoID { get; set; }
 
+        public BeatmapSetOnlineStatus Status { get; set; } = BeatmapSetOnlineStatus.None;
+
         [Required]
         public BeatmapSetInfo BeatmapSet { get; set; }
 
@@ -82,7 +84,7 @@ namespace osu.Game.Beatmaps
         [JsonIgnore]
         public string StoredBookmarks
         {
-            get { return string.Join(",", Bookmarks); }
+            get => string.Join(",", Bookmarks);
             set
             {
                 if (string.IsNullOrEmpty(value))
@@ -93,8 +95,7 @@ namespace osu.Game.Beatmaps
 
                 Bookmarks = value.Split(',').Select(v =>
                 {
-                    int val;
-                    bool result = int.TryParse(v, out val);
+                    bool result = int.TryParse(v, out int val);
                     return new { result, val };
                 }).Where(p => p.result).Select(p => p.val).ToArray();
             }

osu.Game/Beatmaps/BeatmapManager.cs

@@ -1,4 +1,4 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
@@ -104,7 +104,7 @@ namespace osu.Game.Beatmaps
             validateOnlineIds(beatmapSet.Beatmaps);
 
             foreach (BeatmapInfo b in beatmapSet.Beatmaps)
-                fetchAndPopulateOnlineIDs(b, beatmapSet.Beatmaps);
+                fetchAndPopulateOnlineValues(b, beatmapSet.Beatmaps);
 
             // check if a set already exists with the same online id, delete if it does.
             if (beatmapSet.OnlineBeatmapSetID != null)
@@ -388,21 +388,22 @@ namespace osu.Game.Beatmaps
         }
 
         /// <summary>
-        /// Query the API to populate mising OnlineBeatmapID / OnlineBeatmapSetID properties.
+        /// Query the API to populate missing values like OnlineBeatmapID / OnlineBeatmapSetID or (Rank-)Status.
         /// </summary>
         /// <param name="beatmap">The beatmap to populate.</param>
         /// <param name="otherBeatmaps">The other beatmaps contained within this set.</param>
         /// <param name="force">Whether to re-query if the provided beatmap already has populated values.</param>
         /// <returns>True if population was successful.</returns>
-        private bool fetchAndPopulateOnlineIDs(BeatmapInfo beatmap, IEnumerable<BeatmapInfo> otherBeatmaps, bool force = false)
+        private bool fetchAndPopulateOnlineValues(BeatmapInfo beatmap, IEnumerable<BeatmapInfo> otherBeatmaps, bool force = false)
         {
             if (api?.State != APIState.Online)
                 return false;
 
-            if (!force && beatmap.OnlineBeatmapID != null && beatmap.BeatmapSet.OnlineBeatmapSetID != null)
+            if (!force && beatmap.OnlineBeatmapID != null && beatmap.BeatmapSet.OnlineBeatmapSetID != null
+                && beatmap.Status != BeatmapSetOnlineStatus.None && beatmap.BeatmapSet.Status != BeatmapSetOnlineStatus.None)
                 return true;
 
-            Logger.Log("Attempting online lookup for IDs...", LoggingTarget.Database);
+            Logger.Log("Attempting online lookup for the missing values...", LoggingTarget.Database);
 
             try
             {
@@ -414,6 +415,9 @@ namespace osu.Game.Beatmaps
 
                 Logger.Log($"Successfully mapped to {res.OnlineBeatmapSetID} / {res.OnlineBeatmapID}.", LoggingTarget.Database);
 
+                beatmap.Status = res.Status;
+                beatmap.BeatmapSet.Status = res.BeatmapSet.Status;
+
                 if (otherBeatmaps.Any(b => b.OnlineBeatmapID == res.OnlineBeatmapID))
                 {
                     Logger.Log("Another beatmap in the same set already mapped to this ID. We'll skip adding it this time.", LoggingTarget.Database);
@@ -422,6 +426,7 @@ namespace osu.Game.Beatmaps
 
                 beatmap.BeatmapSet.OnlineBeatmapSetID = res.OnlineBeatmapSetID;
                 beatmap.OnlineBeatmapID = res.OnlineBeatmapID;
+
                 return true;
             }
             catch (Exception e)

osu.Game/Beatmaps/BeatmapProcessor.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Linq;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 
 namespace osu.Game.Beatmaps
@@ -44,6 +45,25 @@ namespace osu.Game.Beatmaps
 
         public virtual void PostProcess()
         {
+            void updateNestedCombo(HitObject obj, int comboIndex, int indexInCurrentCombo)
+            {
+                if (obj is IHasComboInformation objectComboInfo)
+                {
+                    objectComboInfo.ComboIndex = comboIndex;
+                    objectComboInfo.IndexInCurrentCombo = indexInCurrentCombo;
+                    foreach (var nestedObject in obj.NestedHitObjects)
+                        updateNestedCombo(nestedObject, comboIndex, indexInCurrentCombo);
+                }
+            }
+
+            foreach (var hitObject in Beatmap.HitObjects)
+            {
+                if (hitObject is IHasComboInformation objectComboInfo)
+                {
+                    foreach (var nested in hitObject.NestedHitObjects)
+                        updateNestedCombo(nested, objectComboInfo.ComboIndex, objectComboInfo.IndexInCurrentCombo);
+                }
+            }
         }
     }
 }

osu.Game/Beatmaps/BeatmapSetInfo.cs

@@ -17,10 +17,12 @@ namespace osu.Game.Beatmaps
 
         public int? OnlineBeatmapSetID
         {
-            get { return onlineBeatmapSetID; }
-            set { onlineBeatmapSetID = value > 0 ? value : null; }
+            get => onlineBeatmapSetID;
+            set => onlineBeatmapSetID = value > 0 ? value : null;
         }
 
+        public BeatmapSetOnlineStatus Status { get; set; } = BeatmapSetOnlineStatus.None;
+
         public BeatmapMetadata Metadata { get; set; }
 
         public List<BeatmapInfo> Beatmaps { get; set; }

osu.Game/Beatmaps/ControlPoints/ControlPointInfo.cs

@@ -55,14 +55,14 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// </summary>
         /// <param name="time">The time to find the sound control point at.</param>
         /// <returns>The sound control point.</returns>
-        public SampleControlPoint SamplePointAt(double time) => binarySearch(SamplePoints, time, SamplePoints.FirstOrDefault());
+        public SampleControlPoint SamplePointAt(double time) => binarySearch(SamplePoints, time, SamplePoints.Count > 0 ? SamplePoints[0] : null);
 
         /// <summary>
         /// Finds the timing control point that is active at <paramref name="time"/>.
         /// </summary>
         /// <param name="time">The time to find the timing control point at.</param>
         /// <returns>The timing control point.</returns>
-        public TimingControlPoint TimingPointAt(double time) => binarySearch(TimingPoints, time, TimingPoints.FirstOrDefault());
+        public TimingControlPoint TimingPointAt(double time) => binarySearch(TimingPoints, time, TimingPoints.Count > 0 ? TimingPoints[0] : null);
 
         /// <summary>
         /// Finds the maximum BPM represented by any timing control point.
@@ -104,17 +104,26 @@ namespace osu.Game.Beatmaps.ControlPoints
             if (time < list[0].Time)
                 return prePoint ?? new T();
 
-            int index = list.BinarySearch(new T { Time = time });
+            if (time >= list[list.Count - 1].Time)
+                return list[list.Count - 1];
 
-            // Check if we've found an exact match (t == time)
-            if (index >= 0)
-                return list[index];
+            int l = 0;
+            int r = list.Count - 2;
 
-            index = ~index;
+            while (l <= r)
+            {
+                int pivot = l + ((r - l) >> 1);
 
-            // BinarySearch will return the index of the first element _greater_ than the search
-            // This is the inactive point - the active point is the one before it (index - 1)
-            return list[index - 1];
+                if (list[pivot].Time < time)
+                    l = pivot + 1;
+                else if (list[pivot].Time > time)
+                    r = pivot - 1;
+                else
+                    return list[pivot];
+            }
+
+            // l will be the first control point with Time > time, but we want the one before it
+            return list[l - 1];
         }
     }
 }

osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs

@@ -16,7 +16,7 @@ namespace osu.Game.Beatmaps.ControlPoints
         /// <summary>
         /// The beat length at this control point.
         /// </summary>
-        public double BeatLength
+        public virtual double BeatLength
         {
             get => beatLength;
             set => beatLength = MathHelper.Clamp(value, 6, 60000);

osu.Game/Beatmaps/Drawables/BeatmapSetOnlineStatusPill.cs

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -14,20 +13,35 @@ namespace osu.Game.Beatmaps.Drawables
     {
         private readonly OsuSpriteText statusText;
 
-        private BeatmapSetOnlineStatus status = BeatmapSetOnlineStatus.None;
+        private BeatmapSetOnlineStatus status;
+
         public BeatmapSetOnlineStatus Status
         {
-            get { return status; }
+            get => status;
             set
             {
-                if (value == status) return;
+                if (status == value)
+                    return;
                 status = value;
 
-                statusText.Text = Enum.GetName(typeof(BeatmapSetOnlineStatus), Status)?.ToUpperInvariant();
+                Alpha = value == BeatmapSetOnlineStatus.None ? 0 : 1;
+                statusText.Text = value.ToString().ToUpperInvariant();
             }
         }
 
-        public BeatmapSetOnlineStatusPill(float textSize, MarginPadding textPadding)
+        public float TextSize
+        {
+            get => statusText.TextSize;
+            set => statusText.TextSize = value;
+        }
+
+        public MarginPadding TextPadding
+        {
+            get => statusText.Padding;
+            set => statusText.Padding = value;
+        }
+
+        public BeatmapSetOnlineStatusPill()
         {
             AutoSizeAxes = Axes.Both;
             Masking = true;
@@ -45,10 +59,10 @@ namespace osu.Game.Beatmaps.Drawables
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Font = @"Exo2.0-Bold",
-                    TextSize = textSize,
-                    Padding = textPadding,
                 },
             };
+
+            Status = BeatmapSetOnlineStatus.None;
         }
     }
 }

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -58,7 +58,7 @@ namespace osu.Game.Beatmaps.Formats
                 hitObject.ApplyDefaults(this.beatmap.ControlPointInfo, this.beatmap.BeatmapInfo.BaseDifficulty);
         }
 
-        protected override bool ShouldSkipLine(string line) => base.ShouldSkipLine(line) || line.StartsWith(" ") || line.StartsWith("_");
+        protected override bool ShouldSkipLine(string line) => base.ShouldSkipLine(line) || line.StartsWith(" ", StringComparison.Ordinal) || line.StartsWith("_", StringComparison.Ordinal);
 
         protected override void ParseLine(Beatmap beatmap, Section section, string line)
         {
@@ -318,12 +318,12 @@ namespace osu.Game.Beatmaps.Formats
 
                 if (timingChange)
                 {
-                    handleTimingControlPoint(new TimingControlPoint
-                    {
-                        Time = time,
-                        BeatLength = beatLength,
-                        TimeSignature = timeSignature
-                    });
+                    var controlPoint = CreateTimingControlPoint();
+                    controlPoint.Time = time;
+                    controlPoint.BeatLength = beatLength;
+                    controlPoint.TimeSignature = timeSignature;
+
+                    handleTimingControlPoint(controlPoint);
                 }
 
                 handleDifficultyControlPoint(new DifficultyControlPoint
@@ -418,6 +418,8 @@ namespace osu.Game.Beatmaps.Formats
 
         private double getOffsetTime(double time) => time + (ApplyOffsets ? offset : 0);
 
+        protected virtual TimingControlPoint CreateTimingControlPoint() => new TimingControlPoint();
+
         [Flags]
         internal enum EffectFlags
         {

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -69,7 +69,7 @@ namespace osu.Game.Beatmaps.Formats
 
         protected string StripComments(string line)
         {
-            var index = line.IndexOf("//", StringComparison.Ordinal);
+            var index = line.AsSpan().IndexOf("//".AsSpan());
             if (index > 0)
                 return line.Substring(0, index);
             return line;
@@ -85,13 +85,19 @@ namespace osu.Game.Beatmaps.Formats
 
             string[] split = pair.Value.Split(',');
 
-            if (split.Length != 3)
-                throw new InvalidOperationException($@"Color specified in incorrect format (should be R,G,B): {pair.Value}");
+            if (split.Length != 3 && split.Length != 4)
+                throw new InvalidOperationException($@"Color specified in incorrect format (should be R,G,B or R,G,B,A): {pair.Value}");
 
-            if (!byte.TryParse(split[0], out var r) || !byte.TryParse(split[1], out var g) || !byte.TryParse(split[2], out var b))
+            Color4 colour;
+
+            try
+            {
+                colour = new Color4(byte.Parse(split[0]), byte.Parse(split[1]), byte.Parse(split[2]), split.Length == 4 ? byte.Parse(split[3]) : (byte)255);
+            }
+            catch (Exception e)
+            {
                 throw new InvalidOperationException(@"Color must be specified with 8-bit integer components");
-
-            Color4 colour = new Color4(r, g, b, 255);
+            }
 
             if (isCombo)
             {

osu.Game/Beatmaps/Formats/LegacyDifficultyCalculatorBeatmapDecoder.cs

@@ -0,0 +1,37 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Linq;
+using osu.Game.Beatmaps.ControlPoints;
+
+namespace osu.Game.Beatmaps.Formats
+{
+    /// <summary>
+    /// A <see cref="LegacyBeatmapDecoder"/> built for difficulty calculation of legacy <see cref="Beatmap"/>s
+    /// <remarks>
+    /// To use this, the decoder must be registered by the application through <see cref="LegacyDifficultyCalculatorBeatmapDecoder.Register"/>.
+    /// Doing so will override any existing <see cref="Beatmap"/> decoders.
+    /// </remarks>
+    /// </summary>
+    public class LegacyDifficultyCalculatorBeatmapDecoder : LegacyBeatmapDecoder
+    {
+        public LegacyDifficultyCalculatorBeatmapDecoder(int version = LATEST_VERSION)
+            : base(version)
+        {
+            ApplyOffsets = false;
+        }
+
+        public new static void Register()
+        {
+            AddDecoder<Beatmap>(@"osu file format v", m => new LegacyDifficultyCalculatorBeatmapDecoder(int.Parse(m.Split('v').Last())));
+        }
+
+        protected override TimingControlPoint CreateTimingControlPoint()
+            => new LegacyDifficultyCalculatorControlPoint();
+
+        private class LegacyDifficultyCalculatorControlPoint : TimingControlPoint
+        {
+            public override double BeatLength { get; set; } = 1000;
+        }
+    }
+}

osu.Game/Beatmaps/IBeatmap.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Beatmaps
         /// <summary>
         /// The hitobjects contained by this beatmap.
         /// </summary>
-        IEnumerable<HitObject> HitObjects { get; }
+        IReadOnlyList<HitObject> HitObjects { get; }
 
         /// <summary>
         /// Returns statistics for the <see cref="HitObjects"/> contained in this beatmap.

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -135,7 +135,7 @@ namespace osu.Game.Beatmaps
 
         public bool BackgroundLoaded => background.IsResultAvailable;
         public Texture Background => background.Value;
-        protected virtual bool BackgroundStillValid(Texture b) => b == null || !b.IsDisposed;
+        protected virtual bool BackgroundStillValid(Texture b) => b == null || b.Available;
         protected abstract Texture GetBackground();
         private readonly RecyclableLazy<Texture> background;
 

osu.Game/Configuration/OsuConfigManager.cs

@@ -83,8 +83,6 @@ namespace osu.Game.Configuration
 
             Set(OsuSetting.ScoreDisplayMode, ScoringMode.Standardised);
 
-            Set(OsuSetting.SpeedChangeVisualisation, SpeedChangeVisualisationMethod.Sequential);
-
             Set(OsuSetting.IncreaseFirstObjectVisibility, true);
 
             // Update
@@ -143,7 +141,6 @@ namespace osu.Game.Configuration
         ChatDisplayHeight,
         Version,
         ShowConvertedBeatmaps,
-        SpeedChangeVisualisation,
         Skin,
         ScreenshotFormat,
         ScreenshotCaptureMenuCursor,

osu.Game/Configuration/SpeedChangeVisualisationMethod.cs

@@ -10,6 +10,8 @@ namespace osu.Game.Configuration
         [Description("Sequential")]
         Sequential,
         [Description("Overlapping")]
-        Overlapping
+        Overlapping,
+        [Description("Constant")]
+        Constant
     }
 }

osu.Game/Database/ArchiveModelManager.cs

@@ -59,7 +59,7 @@ namespace osu.Game.Database
         // ReSharper disable once NotAccessedField.Local (we should keep a reference to this so it is not finalised)
         private ArchiveImportIPCChannel ipc;
 
-        private readonly List<Action> cachedEvents = new List<Action>();
+        private readonly List<Action> queuedEvents = new List<Action>();
 
         /// <summary>
         /// Allows delaying of outwards events until an operation is confirmed (at a database level).
@@ -77,20 +77,27 @@ namespace osu.Game.Database
         /// <param name="perform">Whether the flushed events should be performed.</param>
         private void flushEvents(bool perform)
         {
+            Action[] events;
+            lock (queuedEvents)
+            {
+                events = queuedEvents.ToArray();
+                queuedEvents.Clear();
+            }
+
             if (perform)
             {
-                foreach (var a in cachedEvents)
+                foreach (var a in events)
                     a.Invoke();
             }
 
-            cachedEvents.Clear();
             delayingEvents = false;
         }
 
         private void handleEvent(Action a)
         {
             if (delayingEvents)
-                cachedEvents.Add(a);
+                lock (queuedEvents)
+                    queuedEvents.Add(a);
             else
                 a.Invoke();
         }
@@ -275,17 +282,19 @@ namespace osu.Game.Database
         /// Is a no-op for already deleted items.
         /// </summary>
         /// <param name="item">The item to delete.</param>
-        public void Delete(TModel item)
+        /// <returns>false if no operation was performed</returns>
+        public bool Delete(TModel item)
         {
             using (ContextFactory.GetForWrite())
             {
                 // re-fetch the model on the import context.
-                var foundModel = queryModel().Include(s => s.Files).ThenInclude(f => f.FileInfo).First(s => s.ID == item.ID);
+                var foundModel = queryModel().Include(s => s.Files).ThenInclude(f => f.FileInfo).FirstOrDefault(s => s.ID == item.ID);
 
-                if (foundModel.DeletePending) return;
+                if (foundModel == null || foundModel.DeletePending) return false;
 
                 if (ModelStore.Delete(foundModel))
                     Files.Dereference(foundModel.Files.Select(f => f.FileInfo).ToArray());
+                return true;
             }
         }
 
@@ -432,6 +441,13 @@ namespace osu.Game.Database
                 return Task.CompletedTask;
             }
 
+            if (!stable.ExistsDirectory(ImportFromStablePath))
+            {
+                // This handles situations like when the user does not have a Skins folder
+                Logger.Log($"No {ImportFromStablePath} folder available in osu!stable installation", LoggingTarget.Information, LogLevel.Error);
+                return Task.CompletedTask;
+            }
+
             return Task.Factory.StartNew(() => Import(stable.GetDirectories(ImportFromStablePath).Select(f => stable.GetFullPath(f)).ToArray()), TaskCreationOptions.LongRunning);
         }
 

osu.Game/Graphics/Backgrounds/Background.cs

@@ -6,7 +6,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
-using OpenTK.Graphics;
 
 namespace osu.Game.Graphics.Backgrounds
 {
@@ -28,7 +27,6 @@ namespace osu.Game.Graphics.Backgrounds
                 RelativeSizeAxes = Axes.Both,
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
-                Colour = Color4.DarkGray,
                 FillMode = FillMode.Fill,
             });
         }

osu.Game/Graphics/Backgrounds/Triangles.cs

@@ -30,10 +30,6 @@ namespace osu.Game.Graphics.Backgrounds
         /// </summary>
         private const float edge_smoothness = 1;
 
-        public override bool HandleKeyboardInput => false;
-        public override bool HandleMouseInput => false;
-
-
         public Color4 ColourLight = Color4.White;
         public Color4 ColourDark = Color4.Black;
 

osu.Game/Graphics/Containers/LinkFlowContainer.cs

@@ -20,8 +20,6 @@ namespace osu.Game.Graphics.Containers
         {
         }
 
-        public override bool HandleMouseInput => true;
-
         private OsuGame game;
 
         private Action showNotImplementedError;

osu.Game/Graphics/Containers/OsuFocusedOverlayContainer.cs

@@ -8,7 +8,7 @@ using osu.Framework.Graphics.Containers;
 using OpenTK;
 using osu.Framework.Configuration;
 using osu.Framework.Input.Bindings;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using osu.Game.Audio;
 using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
@@ -22,7 +22,7 @@ namespace osu.Game.Graphics.Containers
 
         protected virtual bool PlaySamplesOnStateChange => true;
 
-        protected override bool BlockPassThroughKeyboard => true;
+        protected override bool BlockNonPositionalInput => true;
 
         private PreviewTrackManager previewTrackManager;
 
@@ -54,20 +54,20 @@ namespace osu.Game.Graphics.Containers
         /// Whether mouse input should be blocked screen-wide while this overlay is visible.
         /// Performing mouse actions outside of the valid extents will hide the overlay.
         /// </summary>
-        public virtual bool BlockScreenWideMouse => BlockPassThroughMouse;
+        public virtual bool BlockScreenWideMouse => BlockPositionalInput;
 
         // receive input outside our bounds so we can trigger a close event on ourselves.
-        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => BlockScreenWideMouse || base.ReceiveMouseInputAt(screenSpacePos);
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => BlockScreenWideMouse || base.ReceivePositionalInputAt(screenSpacePos);
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
-            if (!base.ReceiveMouseInputAt(state.Mouse.NativeState.Position))
+            if (!base.ReceivePositionalInputAt(e.ScreenSpaceMousePosition))
             {
                 State = Visibility.Hidden;
                 return true;
             }
 
-            return base.OnClick(state);
+            return base.OnClick(e);
         }
 
         public virtual bool OnPressed(GlobalAction action)

osu.Game/Graphics/Containers/OsuHoverContainer.cs

@@ -6,7 +6,7 @@ using OpenTK.Graphics;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 
 namespace osu.Game.Graphics.Containers
 {
@@ -18,16 +18,16 @@ namespace osu.Game.Graphics.Containers
 
         protected virtual IEnumerable<Drawable> EffectTargets => new[] { Content };
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
             EffectTargets.ForEach(d => d.FadeColour(HoverColour, 500, Easing.OutQuint));
-            return base.OnHover(state);
+            return base.OnHover(e);
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
             EffectTargets.ForEach(d => d.FadeColour(IdleColour, 500, Easing.OutQuint));
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
         }
 
         [BackgroundDependencyLoader]

osu.Game/Graphics/Containers/OsuScrollContainer.cs

@@ -2,8 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.EventArgs;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using OpenTK.Input;
 
 namespace osu.Game.Graphics.Containers
@@ -21,7 +20,7 @@ namespace osu.Game.Graphics.Containers
         /// </summary>
         public double DistanceDecayOnRightMouseScrollbar = 0.02;
 
-        private bool shouldPerformRightMouseScroll(InputState state) => RightMouseScrollbar && state.Mouse.IsPressed(MouseButton.Right);
+        private bool shouldPerformRightMouseScroll(MouseButtonEvent e) => RightMouseScrollbar && e.Button == MouseButton.Right;
 
         private void scrollToRelative(float value) => ScrollTo(Clamp((value - Scrollbar.DrawSize[ScrollDim] / 2) / Scrollbar.Size[ScrollDim]), true, DistanceDecayOnRightMouseScrollbar);
 
@@ -29,40 +28,40 @@ namespace osu.Game.Graphics.Containers
 
         protected override bool IsDragging => base.IsDragging || mouseScrollBarDragging;
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
-            if (shouldPerformRightMouseScroll(state))
+            if (shouldPerformRightMouseScroll(e))
             {
-                scrollToRelative(state.Mouse.Position[ScrollDim]);
+                scrollToRelative(e.MousePosition[ScrollDim]);
                 return true;
             }
 
-            return base.OnMouseDown(state, args);
+            return base.OnMouseDown(e);
         }
 
-        protected override bool OnDrag(InputState state)
+        protected override bool OnDrag(DragEvent e)
         {
             if (mouseScrollBarDragging)
             {
-                scrollToRelative(state.Mouse.Position[ScrollDim]);
+                scrollToRelative(e.MousePosition[ScrollDim]);
                 return true;
             }
 
-            return base.OnDrag(state);
+            return base.OnDrag(e);
         }
 
-        protected override bool OnDragStart(InputState state)
+        protected override bool OnDragStart(DragStartEvent e)
         {
-            if (shouldPerformRightMouseScroll(state))
+            if (shouldPerformRightMouseScroll(e))
             {
                 mouseScrollBarDragging = true;
                 return true;
             }
 
-            return base.OnDragStart(state);
+            return base.OnDragStart(e);
         }
 
-        protected override bool OnDragEnd(InputState state)
+        protected override bool OnDragEnd(DragEndEvent e)
         {
             if (mouseScrollBarDragging)
             {
@@ -70,7 +69,7 @@ namespace osu.Game.Graphics.Containers
                 return true;
             }
 
-            return base.OnDragEnd(state);
+            return base.OnDragEnd(e);
         }
     }
 }

osu.Game/Graphics/Containers/ParallaxContainer.cs

@@ -67,7 +67,7 @@ namespace osu.Game.Graphics.Containers
 
             if (parallaxEnabled)
             {
-                Vector2 offset = (input.CurrentState.Mouse == null ? Vector2.Zero : ToLocalSpace(input.CurrentState.Mouse.NativeState.Position) - DrawSize / 2) * ParallaxAmount;
+                Vector2 offset = (input.CurrentState.Mouse == null ? Vector2.Zero : ToLocalSpace(input.CurrentState.Mouse.Position) - DrawSize / 2) * ParallaxAmount;
 
                 double elapsed = MathHelper.Clamp(Clock.ElapsedFrameTime, 0, 1000);
 

osu.Game/Graphics/Cursor/MenuCursor.cs

@@ -12,8 +12,7 @@ using osu.Game.Configuration;
 using System;
 using JetBrains.Annotations;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Input.EventArgs;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 using OpenTK.Input;
 
 namespace osu.Game.Graphics.Cursor
@@ -40,11 +39,11 @@ namespace osu.Game.Graphics.Cursor
                 screenshotCursorVisibility.BindTo(screenshotManager.CursorVisibility);
         }
 
-        protected override bool OnMouseMove(InputState state)
+        protected override bool OnMouseMove(MouseMoveEvent e)
         {
             if (dragRotationState != DragRotationState.NotDragging)
             {
-                var position = state.Mouse.Position;
+                var position = e.MousePosition;
                 var distance = Vector2Extensions.Distance(position, positionMouseDown);
                 // don't start rotating until we're moved a minimum distance away from the mouse down location,
                 // else it can have an annoying effect.
@@ -53,7 +52,7 @@ namespace osu.Game.Graphics.Cursor
                 // don't rotate when distance is zero to avoid NaN
                 if (dragRotationState == DragRotationState.Rotating && distance > 0)
                 {
-                    Vector2 offset = state.Mouse.Position - positionMouseDown;
+                    Vector2 offset = e.MousePosition - positionMouseDown;
                     float degrees = (float)MathHelper.RadiansToDegrees(Math.Atan2(-offset.X, offset.Y)) + 24.3f;
 
                     // Always rotate in the direction of least distance
@@ -66,13 +65,13 @@ namespace osu.Game.Graphics.Cursor
                 }
             }
 
-            return base.OnMouseMove(state);
+            return base.OnMouseMove(e);
         }
 
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        protected override bool OnMouseDown(MouseDownEvent e)
         {
             // only trigger animation for main mouse buttons
-            if (args.Button <= MouseButton.Right)
+            if (e.Button <= MouseButton.Right)
             {
                 activeCursor.Scale = new Vector2(1);
                 activeCursor.ScaleTo(0.90f, 800, Easing.OutQuint);
@@ -81,29 +80,29 @@ namespace osu.Game.Graphics.Cursor
                 activeCursor.AdditiveLayer.FadeInFromZero(800, Easing.OutQuint);
             }
 
-            if (args.Button == MouseButton.Left && cursorRotate)
+            if (e.Button == MouseButton.Left && cursorRotate)
             {
                 dragRotationState = DragRotationState.DragStarted;
-                positionMouseDown = state.Mouse.Position;
+                positionMouseDown = e.MousePosition;
             }
-            return base.OnMouseDown(state, args);
+            return base.OnMouseDown(e);
         }
 
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        protected override bool OnMouseUp(MouseUpEvent e)
         {
-            if (!state.Mouse.HasMainButtonPressed)
+            if (!e.IsPressed(MouseButton.Left) && !e.IsPressed(MouseButton.Right))
             {
                 activeCursor.AdditiveLayer.FadeOutFromOne(500, Easing.OutQuint);
                 activeCursor.ScaleTo(1, 500, Easing.OutElastic);
             }
 
-            if (args.Button == MouseButton.Left)
+            if (e.Button == MouseButton.Left)
             {
                 if (dragRotationState == DragRotationState.Rotating)
                     activeCursor.RotateTo(0, 600 * (1 + Math.Abs(activeCursor.Rotation / 720)), Easing.OutElasticHalf);
                 dragRotationState = DragRotationState.NotDragging;
             }
-            return base.OnMouseUp(state, args);
+            return base.OnMouseUp(e);
         }
 
         protected override void PopIn()

osu.Game/Graphics/DrawableDate.cs

@@ -54,8 +54,6 @@ namespace osu.Game.Graphics
             Scheduler.AddDelayed(updateTimeWithReschedule, timeUntilNextUpdate);
         }
 
-        public override bool HandleMouseInput => true;
-
         protected virtual string Format() => Date.Humanize();
 
         private void updateTime() => Text = Format();

osu.Game/Graphics/UserInterface/BreadcrumbControl.cs

@@ -47,10 +47,10 @@ namespace osu.Game.Graphics.UserInterface
             public readonly SpriteIcon Chevron;
 
             //don't allow clicking between transitions and don't make the chevron clickable
-            public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => Alpha == 1f && Text.ReceiveMouseInputAt(screenSpacePos);
+            public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => Alpha == 1f && Text.ReceivePositionalInputAt(screenSpacePos);
 
-            public override bool HandleKeyboardInput => State == Visibility.Visible;
-            public override bool HandleMouseInput => State == Visibility.Visible;
+            public override bool HandleNonPositionalInput => State == Visibility.Visible;
+            public override bool HandlePositionalInput => State == Visibility.Visible;
             public override bool IsRemovable => true;
 
             private Visibility state;

osu.Game/Graphics/UserInterface/DialogButton.cs

@@ -13,7 +13,7 @@ using osu.Game.Graphics.Sprites;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Game.Graphics.Containers;
 using osu.Framework.Configuration;
-using osu.Framework.Input.States;
+using osu.Framework.Input.Events;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -211,9 +211,9 @@ namespace osu.Game.Graphics.UserInterface
             }
         }
 
-        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => backgroundContainer.ReceiveMouseInputAt(screenSpacePos);
+        public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => backgroundContainer.ReceivePositionalInputAt(screenSpacePos);
 
-        protected override bool OnClick(InputState state)
+        protected override bool OnClick(ClickEvent e)
         {
             colourContainer.ResizeTo(new Vector2(1.5f, 1f), click_duration, Easing.In);
             flash();
@@ -225,20 +225,20 @@ namespace osu.Game.Graphics.UserInterface
                 glowContainer.FadeOut();
             });
 
-            return base.OnClick(state);
+            return base.OnClick(e);
         }
 
-        protected override bool OnHover(InputState state)
+        protected override bool OnHover(HoverEvent e)
         {
-            base.OnHover(state);
+            base.OnHover(e);
 
             Selected.Value = true;
             return true;
         }
 
-        protected override void OnHoverLost(InputState state)
+        protected override void OnHoverLost(HoverLostEvent e)
         {
-            base.OnHoverLost(state);
+            base.OnHoverLost(e);
             Selected.Value = false;
         }