Merge remote-tracking branch 'upstream/master' into back-button-part-2

osu.Android.props

@@ -63,6 +63,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.702.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2019.729.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2019.730.0" />
   </ItemGroup>
 </Project>

osu.Desktop/OsuGameDesktop.cs

@@ -1,4 +1,4 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
@@ -38,9 +38,9 @@ namespace osu.Desktop
                 if (Host is DesktopGameHost desktopHost)
                     return new StableStorage(desktopHost);
             }
-            catch (Exception e)
+            catch (Exception)
             {
-                Logger.Error(e, "Error while searching for stable install");
+                Logger.Log("Could not find a stable install", LoggingTarget.Runtime, LogLevel.Important);
             }
 
             return null;
@@ -52,11 +52,7 @@ namespace osu.Desktop
 
             if (!noVersionOverlay)
             {
-                LoadComponentAsync(versionManager = new VersionManager { Depth = int.MinValue }, v =>
+                LoadComponentAsync(versionManager = new VersionManager { Depth = int.MinValue }, Add);
-                {
-                    Add(v);
-                    v.Show();
-                });
 
                 if (RuntimeInfo.OS == RuntimeInfo.Platform.Windows)
                     Add(new SquirrelUpdateManager());

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

@@ -0,0 +1,66 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.IO;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.IO.Stores;
+using osu.Game.Skinning;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public abstract class SkinnableTestScene : OsuGridTestScene
+    {
+        private Skin metricsSkin;
+        private Skin defaultSkin;
+        private Skin specialSkin;
+
+        protected SkinnableTestScene()
+            : base(2, 2)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            var skins = new SkinManager(LocalStorage, ContextFactory, null, audio);
+
+            metricsSkin = getSkinFromResources(skins, "metrics_skin");
+            defaultSkin = getSkinFromResources(skins, "default_skin");
+            specialSkin = getSkinFromResources(skins, "special_skin");
+        }
+
+        public void SetContents(Func<Drawable> creationFunction)
+        {
+            Cell(0).Child = new LocalSkinOverrideContainer(null) { RelativeSizeAxes = Axes.Both }.WithChild(creationFunction());
+            Cell(1).Child = new LocalSkinOverrideContainer(metricsSkin) { RelativeSizeAxes = Axes.Both }.WithChild(creationFunction());
+            Cell(2).Child = new LocalSkinOverrideContainer(defaultSkin) { RelativeSizeAxes = Axes.Both }.WithChild(creationFunction());
+            Cell(3).Child = new LocalSkinOverrideContainer(specialSkin) { RelativeSizeAxes = Axes.Both }.WithChild(creationFunction());
+        }
+
+        private static Skin getSkinFromResources(SkinManager skins, string name)
+        {
+            using (var storage = new DllResourceStore("osu.Game.Rulesets.Osu.Tests.dll"))
+            {
+                var tempName = Path.GetTempFileName();
+
+                File.Delete(tempName);
+                Directory.CreateDirectory(tempName);
+
+                var files = storage.GetAvailableResources().Where(f => f.StartsWith($"Resources/{name}"));
+
+                foreach (var file in files)
+                    using (var stream = storage.GetStream(file))
+                    using (var newFile = File.Create(Path.Combine(tempName, Path.GetFileName(file))))
+                        stream.CopyTo(newFile);
+
+                return skins.GetSkin(skins.Import(tempName).Result);
+            }
+        }
+    }
+}

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

@@ -7,7 +7,6 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using osu.Game.Tests.Visual;
 using osuTK;
 using System.Collections.Generic;
 using System;
@@ -19,37 +18,32 @@ using osu.Game.Rulesets.Scoring;
 namespace osu.Game.Rulesets.Osu.Tests
 {
     [TestFixture]
-    public class TestSceneHitCircle : OsuTestScene
+    public class TestSceneHitCircle : SkinnableTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
             typeof(DrawableHitCircle)
         };
 
-        private readonly Container content;
-        protected override Container<Drawable> Content => content;
-
         private int depthIndex;
 
         public TestSceneHitCircle()
         {
-            base.Content.Add(content = new OsuInputManager(new RulesetInfo { ID = 0 }));
+            AddStep("Miss Big Single", () => SetContents(() => testSingle(2)));
-
+            AddStep("Miss Medium Single", () => SetContents(() => testSingle(5)));
-            AddStep("Miss Big Single", () => testSingle(2));
+            AddStep("Miss Small Single", () => SetContents(() => testSingle(7)));
-            AddStep("Miss Medium Single", () => testSingle(5));
+            AddStep("Hit Big Single", () => SetContents(() => testSingle(2, true)));
-            AddStep("Miss Small Single", () => testSingle(7));
+            AddStep("Hit Medium Single", () => SetContents(() => testSingle(5, true)));
-            AddStep("Hit Big Single", () => testSingle(2, true));
+            AddStep("Hit Small Single", () => SetContents(() => testSingle(7, true)));
-            AddStep("Hit Medium Single", () => testSingle(5, true));
+            AddStep("Miss Big Stream", () => SetContents(() => testStream(2)));
-            AddStep("Hit Small Single", () => testSingle(7, true));
+            AddStep("Miss Medium Stream", () => SetContents(() => testStream(5)));
-            AddStep("Miss Big Stream", () => testStream(2));
+            AddStep("Miss Small Stream", () => SetContents(() => testStream(7)));
-            AddStep("Miss Medium Stream", () => testStream(5));
+            AddStep("Hit Big Stream", () => SetContents(() => testStream(2, true)));
-            AddStep("Miss Small Stream", () => testStream(7));
+            AddStep("Hit Medium Stream", () => SetContents(() => testStream(5, true)));
-            AddStep("Hit Big Stream", () => testStream(2, true));
+            AddStep("Hit Small Stream", () => SetContents(() => testStream(7, true)));
-            AddStep("Hit Medium Stream", () => testStream(5, true));
-            AddStep("Hit Small Stream", () => testStream(7, true));
         }
 
-        private void testSingle(float circleSize, bool auto = false, double timeOffset = 0, Vector2? positionOffset = null)
+        private Drawable testSingle(float circleSize, bool auto = false, double timeOffset = 0, Vector2? positionOffset = null)
         {
             positionOffset = positionOffset ?? Vector2.Zero;
 
@@ -61,27 +55,33 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             circle.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { CircleSize = circleSize });
 
-            var drawable = new TestDrawableHitCircle(circle, auto)
+            var drawable = CreateDrawableHitCircle(circle, auto);
-            {
-                Anchor = Anchor.Centre,
-                Depth = depthIndex++
-            };
 
             foreach (var mod in Mods.Value.OfType<IApplicableToDrawableHitObjects>())
                 mod.ApplyToDrawableHitObjects(new[] { drawable });
 
-            Add(drawable);
+            return drawable;
         }
 
-        private void testStream(float circleSize, bool auto = false)
+        protected virtual TestDrawableHitCircle CreateDrawableHitCircle(HitCircle circle, bool auto) => new TestDrawableHitCircle(circle, auto)
         {
+            Anchor = Anchor.Centre,
+            Depth = depthIndex++
+        };
+
+        private Drawable testStream(float circleSize, bool auto = false)
+        {
+            var container = new Container { RelativeSizeAxes = Axes.Both };
+
             Vector2 pos = new Vector2(-250, 0);
 
             for (int i = 0; i <= 1000; i += 100)
             {
-                testSingle(circleSize, auto, i, pos);
+                container.Add(testSingle(circleSize, auto, i, pos));
                 pos.X += 50;
             }
+
+            return container;
         }
 
         protected class TestDrawableHitCircle : DrawableHitCircle

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

@@ -1,23 +1,22 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Framework.Graphics;
 using osu.Framework.MathUtils;
+using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
     public class TestSceneShaking : TestSceneHitCircle
     {
-        public override void Add(Drawable drawable)
+        protected override TestDrawableHitCircle CreateDrawableHitCircle(HitCircle circle, bool auto)
         {
-            base.Add(drawable);
+            var drawableHitObject = base.CreateDrawableHitCircle(circle, auto);
 
-            if (drawable is TestDrawableHitCircle hitObject)
+            Scheduler.AddDelayed(() => drawableHitObject.TriggerJudgement(),
-            {
+                drawableHitObject.HitObject.StartTime - (drawableHitObject.HitObject.HitWindows.HalfWindowFor(HitResult.Miss) + RNG.Next(0, 300)) - Time.Current);
-                Scheduler.AddDelayed(() => hitObject.TriggerJudgement(),
+
-                    hitObject.HitObject.StartTime - (hitObject.HitObject.HitWindows.HalfWindowFor(HitResult.Miss) + RNG.Next(0, 300)) - Time.Current);
+            return drawableHitObject;
-            }
         }
     }
 }

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

@@ -6,33 +6,29 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
 using osuTK;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableHitCircle : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach
     {
         public ApproachCircle ApproachCircle;
-        private readonly CirclePiece circle;
-        private readonly RingPiece ring;
-        private readonly FlashPiece flash;
-        private readonly ExplodePiece explode;
-        private readonly NumberPiece number;
-        private readonly GlowPiece glow;
 
         private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
         private readonly IBindable<int> stackHeightBindable = new Bindable<int>();
         private readonly IBindable<float> scaleBindable = new Bindable<float>();
 
-        public OsuAction? HitAction => circle.HitAction;
+        public OsuAction? HitAction => hitArea.HitAction;
-
-        private readonly Container explodeContainer;
 
         private readonly Container scaleContainer;
 
+        private readonly HitArea hitArea;
+
         public DrawableHitCircle(HitCircle h)
             : base(h)
         {
@@ -47,44 +43,30 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     RelativeSizeAxes = Axes.Both,
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
-                    Child = explodeContainer = new Container
+                    Children = new Drawable[]
                     {
-                        RelativeSizeAxes = Axes.Both,
+                        hitArea = new HitArea
-                        Origin = Anchor.Centre,
-                        Anchor = Anchor.Centre,
-                        Children = new Drawable[]
                         {
-                            glow = new GlowPiece(),
+                            Hit = () =>
-                            circle = new CirclePiece
                             {
-                                Hit = () =>
+                                if (AllJudged)
-                                {
+                                    return false;
-                                    if (AllJudged)
-                                        return false;
 
-                                    UpdateResult(true);
+                                UpdateResult(true);
-                                    return true;
+                                return true;
-                                },
                             },
-                            number = new NumberPiece
+                        },
-                            {
+                        new SkinnableDrawable("Play/osu/hitcircle", _ => new MainCirclePiece(HitObject.IndexInCurrentCombo)),
-                                Text = (HitObject.IndexInCurrentCombo + 1).ToString(),
+                        ApproachCircle = new ApproachCircle
-                            },
+                        {
-                            ring = new RingPiece(),
+                            Alpha = 0,
-                            flash = new FlashPiece(),
+                            Scale = new Vector2(4),
-                            explode = new ExplodePiece(),
-                            ApproachCircle = new ApproachCircle
-                            {
-                                Alpha = 0,
-                                Scale = new Vector2(4),
-                            }
                         }
                     }
                 },
             };
 
-            //may not be so correct
+            Size = hitArea.DrawSize;
-            Size = circle.DrawSize;
         }
 
         [BackgroundDependencyLoader]
@@ -98,13 +80,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             stackHeightBindable.BindTo(HitObject.StackHeightBindable);
             scaleBindable.BindTo(HitObject.ScaleBindable);
 
-            AccentColour.BindValueChanged(colour =>
+            AccentColour.BindValueChanged(accent => ApproachCircle.Colour = accent.NewValue, true);
-            {
-                explode.Colour = colour.NewValue;
-                glow.Colour = colour.NewValue;
-                circle.Colour = colour.NewValue;
-                ApproachCircle.Colour = colour.NewValue;
-            }, true);
         }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)
@@ -139,8 +115,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected override void UpdateStateTransforms(ArmedState state)
         {
-            glow.FadeOut(400);
-
             switch (state)
             {
                 case ArmedState.Idle:
@@ -148,7 +122,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
                     Expire(true);
 
-                    circle.HitAction = null;
+                    hitArea.HitAction = null;
 
                     // override lifetime end as FadeIn may have been changed externally, causing out expiration to be too early.
                     LifetimeEnd = HitObject.StartTime + HitObject.HitWindows.HalfWindowFor(HitResult.Miss);
@@ -163,29 +137,50 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 case ArmedState.Hit:
                     ApproachCircle.FadeOut(50);
 
-                    const double flash_in = 40;
+                    // todo: temporary / arbitrary
-                    flash.FadeTo(0.8f, flash_in)
+                    this.Delay(800).Expire();
-                         .Then()
-                         .FadeOut(100);
-
-                    explode.FadeIn(flash_in);
-                    explodeContainer.ScaleTo(1.5f, 400, Easing.OutQuad);
-
-                    using (BeginDelayedSequence(flash_in, true))
-                    {
-                        //after the flash, we can hide some elements that were behind it
-                        ring.FadeOut();
-                        circle.FadeOut();
-                        number.FadeOut();
-
-                        this.FadeOut(800);
-                    }
-
-                    Expire();
                     break;
             }
         }
 
         public Drawable ProxiedLayer => ApproachCircle;
+
+        private class HitArea : Drawable, IKeyBindingHandler<OsuAction>
+        {
+            // IsHovered is used
+            public override bool HandlePositionalInput => true;
+
+            public Func<bool> Hit;
+
+            public OsuAction? HitAction;
+
+            public HitArea()
+            {
+                Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+            }
+
+            public bool OnPressed(OsuAction action)
+            {
+                switch (action)
+                {
+                    case OsuAction.LeftButton:
+                    case OsuAction.RightButton:
+                        if (IsHovered && (Hit?.Invoke() ?? false))
+                        {
+                            HitAction = action;
+                            return true;
+                        }
+
+                        break;
+                }
+
+                return false;
+            }
+
+            public bool OnReleased(OsuAction action) => false;
+        }
     }
 }

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

@@ -1,4 +1,4 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Objects.Drawables;

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

@@ -115,7 +115,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             AccentColour.BindValueChanged(colour =>
             {
                 Body.AccentColour = colour.NewValue;
-                Ball.AccentColour = colour.NewValue;
 
                 foreach (var drawableHitObject in NestedHitObjects)
                     drawableHitObject.AccentColour.Value = colour.NewValue;
@@ -166,7 +165,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             Body.AccentColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderTrackOverride") ? s.CustomColours["SliderTrackOverride"] : (Color4?)null) ?? AccentColour.Value;
             Body.BorderColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderBorder") ? s.CustomColours["SliderBorder"] : (Color4?)null) ?? Color4.White;
-            Ball.AccentColour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderBall") ? s.CustomColours["SliderBall"] : (Color4?)null) ?? AccentColour.Value;
         }
 
         private void updatePathRadius() => Body.PathRadius = slider.Scale * sliderPathRadius;

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

@@ -1,24 +1,17 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.Bindings;
+using osu.Framework.Graphics.Sprites;
-using osu.Game.Skinning;
+using osu.Framework.Graphics.Textures;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
-    public class CirclePiece : Container, IKeyBindingHandler<OsuAction>
+    public class CirclePiece : CompositeDrawable
     {
-        // IsHovered is used
-        public override bool HandlePositionalInput => true;
-
-        public Func<bool> Hit;
-
-        public OsuAction? HitAction;
-
         public CirclePiece()
         {
             Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
@@ -27,28 +20,26 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;
-
-            InternalChild = new SkinnableDrawable("Play/osu/hitcircle", _ => new DefaultCirclePiece());
         }
 
-        public bool OnPressed(OsuAction action)
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures)
         {
-            switch (action)
+            InternalChildren = new Drawable[]
             {
-                case OsuAction.LeftButton:
+                new Sprite
-                case OsuAction.RightButton:
+                {
-                    if (IsHovered && (Hit?.Invoke() ?? false))
+                    Anchor = Anchor.Centre,
-                    {
+                    Origin = Anchor.Centre,
-                        HitAction = action;
+                    Texture = textures.Get(@"Play/osu/disc"),
-                        return true;
+                },
-                    }
+                new TrianglesPiece
-
+                {
-                    break;
+                    RelativeSizeAxes = Axes.Both,
-            }
+                    Blending = BlendingMode.Additive,
-
+                    Alpha = 0.5f,
-            return false;
+                }
+            };
         }
-
-        public bool OnReleased(OsuAction action) => false;
     }
 }

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

@@ -1,35 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Allocation;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Graphics.Textures;
-
-namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
-{
-    public class DefaultCirclePiece : Container
-    {
-        [BackgroundDependencyLoader]
-        private void load(TextureStore textures)
-        {
-            RelativeSizeAxes = Axes.Both;
-            Children = new Drawable[]
-            {
-                new Sprite
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Texture = textures.Get(@"Play/osu/disc"),
-                },
-                new TrianglesPiece
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Blending = BlendingMode.Additive,
-                    Alpha = 0.5f,
-                }
-            };
-        }
-    }
-}

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

@@ -0,0 +1,94 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class MainCirclePiece : CompositeDrawable
+    {
+        private readonly CirclePiece circle;
+        private readonly RingPiece ring;
+        private readonly FlashPiece flash;
+        private readonly ExplodePiece explode;
+        private readonly NumberPiece number;
+        private readonly GlowPiece glow;
+
+        public MainCirclePiece(int index)
+        {
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            InternalChildren = new Drawable[]
+            {
+                glow = new GlowPiece(),
+                circle = new CirclePiece(),
+                number = new NumberPiece
+                {
+                    Text = (index + 1).ToString(),
+                },
+                ring = new RingPiece(),
+                flash = new FlashPiece(),
+                explode = new ExplodePiece(),
+            };
+        }
+
+        private readonly IBindable<ArmedState> state = new Bindable<ArmedState>();
+
+        private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
+
+        [BackgroundDependencyLoader]
+        private void load(DrawableHitObject drawableObject)
+        {
+            state.BindTo(drawableObject.State);
+            state.BindValueChanged(updateState, true);
+
+            accentColour.BindTo(drawableObject.AccentColour);
+            accentColour.BindValueChanged(colour =>
+            {
+                explode.Colour = colour.NewValue;
+                glow.Colour = colour.NewValue;
+                circle.Colour = colour.NewValue;
+            }, true);
+        }
+
+        private void updateState(ValueChangedEvent<ArmedState> state)
+        {
+            glow.FadeOut(400);
+
+            switch (state.NewValue)
+            {
+                case ArmedState.Hit:
+                    const double flash_in = 40;
+                    const double flash_out = 100;
+
+                    flash.FadeTo(0.8f, flash_in)
+                         .Then()
+                         .FadeOut(flash_out);
+
+                    explode.FadeIn(flash_in);
+                    this.ScaleTo(1.5f, 400, Easing.OutQuad);
+
+                    using (BeginDelayedSequence(flash_in, true))
+                    {
+                        //after the flash, we can hide some elements that were behind it
+                        ring.FadeOut();
+                        circle.FadeOut();
+                        number.FadeOut();
+
+                        this.FadeOut(800);
+                    }
+
+                    break;
+            }
+        }
+    }
+}

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

@@ -3,11 +3,13 @@
 
 using System;
 using System.Linq;
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input;
 using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osuTK.Graphics;
 using osu.Game.Skinning;
@@ -17,88 +19,44 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
     public class SliderBall : CircularContainer, ISliderProgress, IRequireHighFrequencyMousePosition
     {
-        private Color4 accentColour = Color4.Black;
-
         public Func<OsuAction?> GetInitialHitAction;
 
-        /// <summary>
-        /// The colour that is used for the slider ball.
-        /// </summary>
-        public Color4 AccentColour
-        {
-            get => accentColour;
-            set
-            {
-                accentColour = value;
-                if (drawableBall != null)
-                    drawableBall.Colour = value;
-            }
-        }
-
         private readonly Slider slider;
         public readonly Drawable FollowCircle;
-        private Drawable drawableBall;
         private readonly DrawableSlider drawableSlider;
 
         public SliderBall(Slider slider, DrawableSlider drawableSlider = null)
         {
             this.drawableSlider = drawableSlider;
             this.slider = slider;
-            Masking = true;
+
-            AutoSizeAxes = Axes.Both;
             Blending = BlendingMode.Additive;
             Origin = Anchor.Centre;
 
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
+
             Children = new[]
             {
-                FollowCircle = new Container
+                FollowCircle = new FollowCircleContainer
                 {
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
-                    Width = OsuHitObject.OBJECT_RADIUS * 2,
+                    RelativeSizeAxes = Axes.Both,
-                    Height = OsuHitObject.OBJECT_RADIUS * 2,
                     Alpha = 0,
-                    Child = new SkinnableDrawable("Play/osu/sliderfollowcircle", _ => new CircularContainer
+                    Child = new SkinnableDrawable("Play/osu/sliderfollowcircle", _ => new DefaultFollowCircle()),
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Masking = true,
-                        BorderThickness = 5,
-                        BorderColour = Color4.Orange,
-                        Blending = BlendingMode.Additive,
-                        Child = new Box
-                        {
-                            Colour = Color4.Orange,
-                            RelativeSizeAxes = Axes.Both,
-                            Alpha = 0.2f,
-                        }
-                    }),
                 },
                 new CircularContainer
                 {
                     Masking = true,
-                    AutoSizeAxes = Axes.Both,
+                    RelativeSizeAxes = Axes.Both,
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
                     Alpha = 1,
                     Child = new Container
                     {
-                        Width = OsuHitObject.OBJECT_RADIUS * 2,
+                        RelativeSizeAxes = Axes.Both,
-                        Height = OsuHitObject.OBJECT_RADIUS * 2,
                         // TODO: support skin filename animation (sliderb0, sliderb1...)
-                        Child = new SkinnableDrawable("Play/osu/sliderb", _ => new CircularContainer
+                        Child = new SkinnableDrawable("Play/osu/sliderball", _ => new DefaultSliderBall()),
-                        {
-                            Masking = true,
-                            RelativeSizeAxes = Axes.Both,
-                            BorderThickness = 10,
-                            BorderColour = Color4.White,
-                            Alpha = 1,
-                            Child = drawableBall = new Box
-                            {
-                                Colour = AccentColour,
-                                RelativeSizeAxes = Axes.Both,
-                                Alpha = 0.4f,
-                            }
-                        }),
                     }
                 }
             };
@@ -191,7 +149,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                 // in valid time range
                 Time.Current >= slider.StartTime && Time.Current < slider.EndTime &&
                 // in valid position range
-                lastScreenSpaceMousePosition.HasValue && base.ReceivePositionalInputAt(lastScreenSpaceMousePosition.Value) &&
+                lastScreenSpaceMousePosition.HasValue && FollowCircle.ReceivePositionalInputAt(lastScreenSpaceMousePosition.Value) &&
                 // valid action
                 (actions?.Any(isValidTrackingAction) ?? false);
         }
@@ -214,5 +172,62 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         {
             Position = slider.CurvePositionAt(completionProgress);
         }
+
+        private class FollowCircleContainer : Container
+        {
+            public override bool HandlePositionalInput => true;
+        }
+
+        public class DefaultFollowCircle : CompositeDrawable
+        {
+            public DefaultFollowCircle()
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                InternalChild = new CircularContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Masking = true,
+                    BorderThickness = 5,
+                    BorderColour = Color4.Orange,
+                    Blending = BlendingMode.Additive,
+                    Child = new Box
+                    {
+                        Colour = Color4.Orange,
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0.2f,
+                    }
+                };
+            }
+        }
+
+        public class DefaultSliderBall : CompositeDrawable
+        {
+            [BackgroundDependencyLoader]
+            private void load(DrawableHitObject drawableObject, ISkinSource skin)
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                float radius = skin.GetValue<SkinConfiguration, float?>(s => s.SliderPathRadius) ?? OsuHitObject.OBJECT_RADIUS;
+
+                InternalChild = new CircularContainer
+                {
+                    Masking = true,
+                    RelativeSizeAxes = Axes.Both,
+                    Scale = new Vector2(radius / OsuHitObject.OBJECT_RADIUS),
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    BorderThickness = 10,
+                    BorderColour = Color4.White,
+                    Alpha = 1,
+                    Child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.White,
+                        Alpha = 0.4f,
+                    }
+                };
+            }
+        }
     }
 }

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

@@ -18,6 +18,8 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
 {
     public class OsuCursor : SkinReloadableDrawable
     {
+        private const float size = 28;
+
         private bool cursorExpand;
 
         private Bindable<double> cursorScale;
@@ -30,7 +32,8 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
         public OsuCursor()
         {
             Origin = Anchor.Centre;
-            Size = new Vector2(28);
+
+            Size = new Vector2(size);
         }
 
         protected override void SkinChanged(ISkinSource skin, bool allowFallback)
@@ -46,62 +49,7 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
                 RelativeSizeAxes = Axes.Both,
                 Origin = Anchor.Centre,
                 Anchor = Anchor.Centre,
-                Child = scaleTarget = new SkinnableDrawable("cursor", _ => new CircularContainer
+                Child = scaleTarget = new SkinnableDrawable("Play/osu/cursor", _ => new DefaultCursor(), confineMode: ConfineMode.NoScaling)
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Masking = true,
-                    BorderThickness = Size.X / 6,
-                    BorderColour = Color4.White,
-                    EdgeEffect = new EdgeEffectParameters
-                    {
-                        Type = EdgeEffectType.Shadow,
-                        Colour = Color4.Pink.Opacity(0.5f),
-                        Radius = 5,
-                    },
-                    Children = new Drawable[]
-                    {
-                        new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            Alpha = 0,
-                            AlwaysPresent = true,
-                        },
-                        new CircularContainer
-                        {
-                            Origin = Anchor.Centre,
-                            Anchor = Anchor.Centre,
-                            RelativeSizeAxes = Axes.Both,
-                            Masking = true,
-                            BorderThickness = Size.X / 3,
-                            BorderColour = Color4.White.Opacity(0.5f),
-                            Children = new Drawable[]
-                            {
-                                new Box
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Alpha = 0,
-                                    AlwaysPresent = true,
-                                },
-                            },
-                        },
-                        new CircularContainer
-                        {
-                            Origin = Anchor.Centre,
-                            Anchor = Anchor.Centre,
-                            RelativeSizeAxes = Axes.Both,
-                            Scale = new Vector2(0.1f),
-                            Masking = true,
-                            Children = new Drawable[]
-                            {
-                                new Box
-                                {
-                                    RelativeSizeAxes = Axes.Both,
-                                    Colour = Color4.White,
-                                },
-                            },
-                        },
-                    }
-                }, confineMode: ConfineMode.NoScaling)
                 {
                     Origin = Anchor.Centre,
                     Anchor = Anchor.Centre,
@@ -144,5 +92,76 @@ namespace osu.Game.Rulesets.Osu.UI.Cursor
         }
 
         public void Contract() => expandTarget.ScaleTo(released_scale, 100, Easing.OutQuad);
+
+        private class DefaultCursor : CompositeDrawable
+        {
+            public DefaultCursor()
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+
+                InternalChildren = new Drawable[]
+                {
+                    new CircularContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Masking = true,
+                        BorderThickness = size / 6,
+                        BorderColour = Color4.White,
+                        EdgeEffect = new EdgeEffectParameters
+                        {
+                            Type = EdgeEffectType.Shadow,
+                            Colour = Color4.Pink.Opacity(0.5f),
+                            Radius = 5,
+                        },
+                        Children = new Drawable[]
+                        {
+                            new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Alpha = 0,
+                                AlwaysPresent = true,
+                            },
+                            new CircularContainer
+                            {
+                                Origin = Anchor.Centre,
+                                Anchor = Anchor.Centre,
+                                RelativeSizeAxes = Axes.Both,
+                                Masking = true,
+                                BorderThickness = size / 3,
+                                BorderColour = Color4.White.Opacity(0.5f),
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Alpha = 0,
+                                        AlwaysPresent = true,
+                                    },
+                                },
+                            },
+                            new CircularContainer
+                            {
+                                Origin = Anchor.Centre,
+                                Anchor = Anchor.Centre,
+                                RelativeSizeAxes = Axes.Both,
+                                Scale = new Vector2(0.1f),
+                                Masking = true,
+                                Children = new Drawable[]
+                                {
+                                    new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both,
+                                        Colour = Color4.White,
+                                    },
+                                },
+                            },
+                        }
+                    }
+                };
+            }
+        }
     }
 }

osu.Game.Tests/Visual/Background/TestSceneUserDimContainer.cs

@@ -17,7 +17,6 @@ using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
 using osu.Game.Configuration;
-using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -51,26 +50,14 @@ namespace osu.Game.Tests.Visual.Background
         private DummySongSelect songSelect;
         private TestPlayerLoader playerLoader;
         private TestPlayer player;
-        private DatabaseContextFactory factory;
         private BeatmapManager manager;
         private RulesetStore rulesets;
 
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
         {
-            factory = new DatabaseContextFactory(LocalStorage);
+            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            factory.ResetDatabase();
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, Beatmap.Default));
-
-            using (var usage = factory.Get())
-                usage.Migrate();
-
-            factory.ResetDatabase();
-
-            using (var usage = factory.Get())
-                usage.Migrate();
-
-            Dependencies.Cache(rulesets = new RulesetStore(factory));
-            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, factory, rulesets, null, audio, host, Beatmap.Default));
             Dependencies.Cache(new OsuConfigManager(LocalStorage));
 
             manager.Import(TestResources.GetTestBeatmapForImport()).Wait();

osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs

@@ -15,7 +15,6 @@ using osu.Framework.MathUtils;
 using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
-using osu.Game.Database;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
@@ -35,7 +34,6 @@ namespace osu.Game.Tests.Visual.SongSelect
         private RulesetStore rulesets;
 
         private WorkingBeatmap defaultBeatmap;
-        private DatabaseContextFactory factory;
 
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
@@ -74,28 +72,11 @@ namespace osu.Game.Tests.Visual.SongSelect
 
         private TestSongSelect songSelect;
 
-        protected override void Dispose(bool isDisposing)
-        {
-            factory.ResetDatabase();
-            base.Dispose(isDisposing);
-        }
-
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
         {
-            factory = new DatabaseContextFactory(LocalStorage);
+            Dependencies.Cache(rulesets = new RulesetStore(ContextFactory));
-            factory.ResetDatabase();
+            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, ContextFactory, rulesets, null, audio, host, defaultBeatmap = Beatmap.Default));
-
-            using (var usage = factory.Get())
-                usage.Migrate();
-
-            factory.ResetDatabase();
-
-            using (var usage = factory.Get())
-                usage.Migrate();
-
-            Dependencies.Cache(rulesets = new RulesetStore(factory));
-            Dependencies.Cache(manager = new BeatmapManager(LocalStorage, factory, rulesets, null, audio, host, defaultBeatmap = Beatmap.Default));
 
             Beatmap.SetDefault();
         }

osu.Game.Tournament.Tests/Components/TestSceneDrawableTournamentMatch.cs

@@ -5,14 +5,13 @@ using System;
 using System.Collections.Generic;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Tests.Visual;
 using osu.Game.Tournament.Components;
 using osu.Game.Tournament.Models;
 using osu.Game.Tournament.Screens.Ladder.Components;
 
 namespace osu.Game.Tournament.Tests.Components
 {
-    public class TestSceneDrawableTournamentMatch : OsuTestScene
+    public class TestSceneDrawableTournamentMatch : TournamentTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Game.Tournament.Tests/LadderTestScene.cs

@@ -1,13 +1,14 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using NUnit.Framework;
 using osu.Framework.Allocation;
-using osu.Game.Tests.Visual;
 using osu.Game.Tournament.Models;
 
 namespace osu.Game.Tournament.Tests
 {
-    public abstract class LadderTestScene : OsuTestScene
+    [TestFixture]
+    public abstract class LadderTestScene : TournamentTestScene
     {
         [Resolved]
         protected LadderInfo Ladder { get; private set; }

osu.Game.Tournament.Tests/Screens/TestSceneGameplayScreen.cs

@@ -2,13 +2,12 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Game.Tests.Visual;
 using osu.Game.Tournament.Components;
 using osu.Game.Tournament.Screens.Gameplay;
 
 namespace osu.Game.Tournament.Tests.Screens
 {
-    public class TestSceneGameplayScreen : OsuTestScene
+    public class TestSceneGameplayScreen : TournamentTestScene
     {
         [Cached]
         private TournamentMatchChatDisplay chat = new TournamentMatchChatDisplay();

osu.Game.Tournament.Tests/Screens/TestSceneScheduleScreen.cs

@@ -2,12 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Game.Tests.Visual;
 using osu.Game.Tournament.Screens.Schedule;
 
 namespace osu.Game.Tournament.Tests.Screens
 {
-    public class TestSceneScheduleScreen : OsuTestScene
+    public class TestSceneScheduleScreen : TournamentTestScene
     {
         [BackgroundDependencyLoader]
         private void load()

osu.Game.Tournament.Tests/Screens/TestSceneShowcaseScreen.cs

@@ -2,12 +2,11 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Allocation;
-using osu.Game.Tests.Visual;
 using osu.Game.Tournament.Screens.Showcase;
 
 namespace osu.Game.Tournament.Tests.Screens
 {
-    public class TestSceneShowcaseScreen : OsuTestScene
+    public class TestSceneShowcaseScreen : TournamentTestScene
     {
         [BackgroundDependencyLoader]
         private void load()

osu.Game.Tournament.Tests/TestSceneTournamentSceneManager.cs

@@ -3,11 +3,10 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Platform;
-using osu.Game.Tests.Visual;
 
 namespace osu.Game.Tournament.Tests
 {
-    public class TestSceneTournamentSceneManager : OsuTestScene
+    public class TestSceneTournamentSceneManager : TournamentTestScene
     {
         [BackgroundDependencyLoader]
         private void load(Storage storage)

osu.Game.Tournament.Tests/TournamentTestScene.cs

@@ -0,0 +1,28 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Testing;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Tournament.Tests
+{
+    public abstract class TournamentTestScene : OsuTestScene
+    {
+        protected override ITestSceneTestRunner CreateRunner() => new TournamentTestSceneTestRunner();
+
+        public class TournamentTestSceneTestRunner : TournamentGameBase, ITestSceneTestRunner
+        {
+            private TestSceneTestRunner.TestRunner runner;
+
+            protected override void LoadAsyncComplete()
+            {
+                // this has to be run here rather than LoadComplete because
+                // TestScene.cs is checking the IsLoaded state (on another thread) and expects
+                // the runner to be loaded at that point.
+                Add(runner = new TestSceneTestRunner.TestRunner());
+            }
+
+            public void RunTestBlocking(TestScene test) => runner.RunTestBlocking(test);
+        }
+    }
+}

osu.Game.Tournament/TournamentGameBase.cs

@@ -9,15 +9,20 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input;
 using osu.Framework.IO.Stores;
 using osu.Framework.Platform;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API.Requests;
 using osu.Game.Tournament.IPC;
 using osu.Game.Tournament.Models;
+using osuTK.Graphics;
 using osuTK.Input;
 
 namespace osu.Game.Tournament
@@ -35,6 +40,8 @@ namespace osu.Game.Tournament
         private Bindable<Size> windowSize;
         private FileBasedIPC ipc;
 
+        private Drawable heightWarning;
+
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
             return dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
@@ -53,6 +60,12 @@ namespace osu.Game.Tournament
             this.storage = storage;
 
             windowSize = frameworkConfig.GetBindable<Size>(FrameworkSetting.WindowedSize);
+            windowSize.BindValueChanged(size => ScheduleAfterChildren(() =>
+            {
+                var minWidth = (int)(size.NewValue.Height / 9f * 16 + 400);
+
+                heightWarning.Alpha = size.NewValue.Width < minWidth ? 1 : 0;
+            }), true);
 
             readBracket();
 
@@ -61,16 +74,43 @@ namespace osu.Game.Tournament
             dependencies.CacheAs<MatchIPCInfo>(ipc = new FileBasedIPC());
             Add(ipc);
 
-            Add(new OsuButton
+            AddRange(new[]
             {
-                Text = "Save Changes",
+                new OsuButton
-                Width = 140,
+                {
-                Height = 50,
+                    Text = "Save Changes",
-                Depth = float.MinValue,
+                    Width = 140,
-                Anchor = Anchor.BottomRight,
+                    Height = 50,
-                Origin = Anchor.BottomRight,
+                    Depth = float.MinValue,
-                Padding = new MarginPadding(10),
+                    Anchor = Anchor.BottomRight,
-                Action = SaveChanges,
+                    Origin = Anchor.BottomRight,
+                    Padding = new MarginPadding(10),
+                    Action = SaveChanges,
+                },
+                heightWarning = new Container
+                {
+                    Masking = true,
+                    CornerRadius = 5,
+                    Depth = float.MinValue,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    AutoSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Colour = Color4.Red,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        new SpriteText
+                        {
+                            Text = "Please make the window wider",
+                            Font = OsuFont.Default.With(weight: "bold"),
+                            Colour = Color4.White,
+                            Padding = new MarginPadding(20)
+                        }
+                    }
+                },
             });
         }
 
@@ -195,18 +235,6 @@ namespace osu.Game.Tournament
             base.LoadComplete();
         }
 
-        protected override void Update()
-        {
-            base.Update();
-            var minWidth = (int)(windowSize.Value.Height / 9f * 16 + 400);
-
-            if (windowSize.Value.Width < minWidth)
-            {
-                // todo: can be removed after ppy/osu-framework#1975
-                windowSize.Value = Host.Window.ClientSize = new Size(minWidth, windowSize.Value.Height);
-            }
-        }
-
         protected virtual void SaveChanges()
         {
             foreach (var r in ladder.Rounds)

osu.Game/Graphics/Containers/OsuScrollContainer.cs

@@ -27,11 +27,12 @@ namespace osu.Game.Graphics.Containers
 
         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);
+        private void scrollFromMouseEvent(MouseEvent e) =>
+            ScrollTo(Clamp(ToLocalSpace(e.ScreenSpaceMousePosition)[ScrollDim] / DrawSize[ScrollDim]) * Content.DrawSize[ScrollDim], true, DistanceDecayOnRightMouseScrollbar);
 
-        private bool mouseScrollBarDragging;
+        private bool rightMouseDragging;
 
-        protected override bool IsDragging => base.IsDragging || mouseScrollBarDragging;
+        protected override bool IsDragging => base.IsDragging || rightMouseDragging;
 
         public OsuScrollContainer(Direction scrollDirection = Direction.Vertical)
             : base(scrollDirection)
@@ -42,7 +43,7 @@ namespace osu.Game.Graphics.Containers
         {
             if (shouldPerformRightMouseScroll(e))
             {
-                scrollToRelative(e.MousePosition[ScrollDim]);
+                scrollFromMouseEvent(e);
                 return true;
             }
 
@@ -51,9 +52,9 @@ namespace osu.Game.Graphics.Containers
 
         protected override bool OnDrag(DragEvent e)
         {
-            if (mouseScrollBarDragging)
+            if (rightMouseDragging)
             {
-                scrollToRelative(e.MousePosition[ScrollDim]);
+                scrollFromMouseEvent(e);
                 return true;
             }
 
@@ -64,7 +65,7 @@ namespace osu.Game.Graphics.Containers
         {
             if (shouldPerformRightMouseScroll(e))
             {
-                mouseScrollBarDragging = true;
+                rightMouseDragging = true;
                 return true;
             }
 
@@ -73,9 +74,9 @@ namespace osu.Game.Graphics.Containers
 
         protected override bool OnDragEnd(DragEndEvent e)
         {
-            if (mouseScrollBarDragging)
+            if (rightMouseDragging)
             {
-                mouseScrollBarDragging = false;
+                rightMouseDragging = false;
                 return true;
             }
 

osu.Game/OsuGame.cs

@@ -268,7 +268,16 @@ namespace osu.Game
         {
             // The given ScoreInfo may have missing properties if it was retrieved from online data. Re-retrieve it from the database
             // to ensure all the required data for presenting a replay are present.
-            var databasedScoreInfo = ScoreManager.Query(s => s.OnlineScoreID == score.OnlineScoreID);
+            var databasedScoreInfo = score.OnlineScoreID != null
+                ? ScoreManager.Query(s => s.OnlineScoreID == score.OnlineScoreID)
+                : ScoreManager.Query(s => s.Hash == score.Hash);
+
+            if (databasedScoreInfo == null)
+            {
+                Logger.Log("The requested score could not be found locally.", LoggingTarget.Information);
+                return;
+            }
+
             var databasedScore = ScoreManager.GetScore(databasedScoreInfo);
 
             if (databasedScore.Replay == null)

osu.Game/Overlays/Profile/Header/Components/AddFriendButton.cs

@@ -53,6 +53,6 @@ namespace osu.Game.Overlays.Profile.Header.Components
             User.BindValueChanged(user => updateFollowers(user.NewValue), true);
         }
 
-        private void updateFollowers(User user) => followerText.Text = user?.FollowerCount?.Length > 0 ? user.FollowerCount[0].ToString("#,##0") : "0";
+        private void updateFollowers(User user) => followerText.Text = user?.FollowerCount.ToString("#,##0");
     }
 }

osu.Game/Overlays/Settings/Sections/Debug/GeneralSettings.cs

@@ -27,11 +27,6 @@ namespace osu.Game.Overlays.Settings.Sections.Debug
                     Bindable = frameworkConfig.GetBindable<bool>(FrameworkSetting.PerformanceLogging)
                 },
                 new SettingsCheckbox
-                {
-                    LabelText = "Bypass caching (slow)",
-                    Bindable = config.GetBindable<bool>(DebugSetting.BypassCaching)
-                },
-                new SettingsCheckbox
                 {
                     LabelText = "Bypass front-to-back render pass",
                     Bindable = config.GetBindable<bool>(DebugSetting.BypassFrontToBackPass)

osu.Game/Overlays/Settings/Sections/Debug/MemorySettings.cs

@@ -1,26 +1,26 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
+using osu.Framework.Platform;
 
 namespace osu.Game.Overlays.Settings.Sections.Debug
 {
-    public class GCSettings : SettingsSubsection
+    public class MemorySettings : SettingsSubsection
     {
-        protected override string Header => "Garbage Collector";
+        protected override string Header => "Memory";
 
         [BackgroundDependencyLoader]
-        private void load(FrameworkDebugConfigManager config)
+        private void load(FrameworkDebugConfigManager config, GameHost host)
         {
             Children = new Drawable[]
             {
                 new SettingsButton
                 {
-                    Text = "Force garbage collection",
+                    Text = "Clear all caches",
-                    Action = GC.Collect
+                    Action = host.Collect
                 },
             };
         }

osu.Game/Overlays/Settings/Sections/DebugSection.cs

@@ -17,7 +17,7 @@ namespace osu.Game.Overlays.Settings.Sections
             Children = new Drawable[]
             {
                 new GeneralSettings(),
-                new GCSettings(),
+                new MemorySettings(),
             };
         }
     }

osu.Game/Overlays/Settings/Sections/SkinSection.cs

@@ -107,6 +107,8 @@ namespace osu.Game.Overlays.Settings.Sections
             private class SkinDropdownControl : DropdownControl
             {
                 protected override string GenerateItemText(SkinInfo item) => item.ToString();
+
+                protected override DropdownMenu CreateMenu() => base.CreateMenu().With(m => m.MaxHeight = 200);
             }
         }
     }

osu.Game/Screens/Select/BeatmapInfoWedge.cs

@@ -141,6 +141,7 @@ namespace osu.Game.Screens.Select
             private readonly RulesetInfo ruleset;
 
             public BufferedWedgeInfo(WorkingBeatmap beatmap, RulesetInfo userRuleset)
+                : base(pixelSnapping: true)
             {
                 this.beatmap = beatmap;
                 ruleset = userRuleset ?? beatmap.BeatmapInfo.Ruleset;
@@ -152,7 +153,6 @@ namespace osu.Game.Screens.Select
                 var beatmapInfo = beatmap.BeatmapInfo;
                 var metadata = beatmapInfo.Metadata ?? beatmap.BeatmapSetInfo?.Metadata ?? new BeatmapMetadata();
 
-                PixelSnapping = true;
                 CacheDrawnFrameBuffer = true;
                 RelativeSizeAxes = Axes.Both;
 

osu.Game/Skinning/LegacySkin.cs

@@ -6,15 +6,22 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
 using osu.Game.Database;
+using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Skinning
 {
@@ -36,6 +43,8 @@ namespace osu.Game.Skinning
         {
         }
 
+        private readonly bool hasHitCircle;
+
         protected LegacySkin(SkinInfo skin, IResourceStore<byte[]> storage, AudioManager audioManager, string filename)
             : base(skin)
         {
@@ -49,8 +58,6 @@ namespace osu.Game.Skinning
             Samples = audioManager.GetSampleStore(storage);
             Textures = new TextureStore(new TextureLoaderStore(storage));
 
-            bool hasHitCircle = false;
-
             using (var testStream = storage.GetStream("hitcircle"))
                 hasHitCircle |= testStream != null;
 
@@ -71,6 +78,24 @@ namespace osu.Game.Skinning
         {
             switch (componentName)
             {
+                case "Play/osu/cursor":
+                    if (GetTexture("cursor") != null)
+                        return new LegacyCursor();
+
+                    return null;
+
+                case "Play/osu/sliderball":
+                    if (GetTexture("sliderb") != null)
+                        return new LegacySliderBall();
+
+                    return null;
+
+                case "Play/osu/hitcircle":
+                    if (hasHitCircle)
+                        return new LegacyMainCirclePiece();
+
+                    return null;
+
                 case "Play/Miss":
                     componentName = "hit0";
                     break;
@@ -109,6 +134,16 @@ namespace osu.Game.Skinning
             return new Sprite { Texture = texture };
         }
 
+        public class LegacySliderBall : Sprite
+        {
+            [BackgroundDependencyLoader]
+            private void load(ISkinSource skin)
+            {
+                Texture = skin.GetTexture("sliderb");
+                Colour = skin.GetValue<SkinConfiguration, Color4?>(s => s.CustomColours.ContainsKey("SliderBall") ? s.CustomColours["SliderBall"] : (Color4?)null) ?? Color4.White;
+            }
+        }
+
         public override Texture GetTexture(string componentName)
         {
             float ratio = 2;
@@ -121,20 +156,8 @@ namespace osu.Game.Skinning
             }
 
             if (texture != null)
-            {
                 texture.ScaleAdjust = ratio;
 
-                switch (componentName)
-                {
-                    case "cursormiddle":
-                    case "cursortrail":
-                    case "cursor":
-                        // apply inverse of adjustment in OsuPlayfieldAdjustmentContainer for non-gameplay-scale textures.
-                        texture.ScaleAdjust *= 1.6f;
-                        break;
-                }
-            }
-
             return texture;
         }
 
@@ -243,5 +266,112 @@ namespace osu.Game.Skinning
                 return texture;
             }
         }
+
+        public class LegacyCursor : CompositeDrawable
+        {
+            public LegacyCursor()
+            {
+                Size = new Vector2(50);
+
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(ISkinSource skin)
+            {
+                InternalChildren = new Drawable[]
+                {
+                    new NonPlayfieldSprite
+                    {
+                        Texture = skin.GetTexture("cursormiddle"),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    },
+                    new NonPlayfieldSprite
+                    {
+                        Texture = skin.GetTexture("cursor"),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                };
+            }
+        }
+
+        public class LegacyMainCirclePiece : CompositeDrawable
+        {
+            public LegacyMainCirclePiece()
+            {
+                Size = new Vector2(128);
+            }
+
+            private readonly IBindable<ArmedState> state = new Bindable<ArmedState>();
+
+            private readonly Bindable<Color4> accentColour = new Bindable<Color4>();
+
+            [BackgroundDependencyLoader]
+            private void load(DrawableHitObject drawableObject, ISkinSource skin)
+            {
+                Sprite hitCircleSprite;
+
+                InternalChildren = new Drawable[]
+                {
+                    hitCircleSprite = new Sprite
+                    {
+                        Texture = skin.GetTexture("hitcircle"),
+                        Colour = drawableObject.AccentColour.Value,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    },
+                    new SkinnableSpriteText("Play/osu/number-text", _ => new OsuSpriteText
+                    {
+                        Font = OsuFont.Numeric.With(size: 40),
+                        UseFullGlyphHeight = false,
+                    }, confineMode: ConfineMode.NoScaling)
+                    {
+                        Text = (((IHasComboInformation)drawableObject.HitObject).IndexInCurrentCombo + 1).ToString()
+                    },
+                    new Sprite
+                    {
+                        Texture = skin.GetTexture("hitcircleoverlay"),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    }
+                };
+
+                state.BindTo(drawableObject.State);
+                state.BindValueChanged(updateState, true);
+
+                accentColour.BindTo(drawableObject.AccentColour);
+                accentColour.BindValueChanged(colour => hitCircleSprite.Colour = colour.NewValue, true);
+            }
+
+            private void updateState(ValueChangedEvent<ArmedState> state)
+            {
+                const double legacy_fade_duration = 240;
+
+                switch (state.NewValue)
+                {
+                    case ArmedState.Hit:
+                        this.FadeOut(legacy_fade_duration, Easing.Out);
+                        this.ScaleTo(1.4f, legacy_fade_duration, Easing.Out);
+                        break;
+                }
+            }
+        }
+
+        private class NonPlayfieldSprite : Sprite
+        {
+            public override Texture Texture
+            {
+                get => base.Texture;
+                set
+                {
+                    if (value != null)
+                        value.ScaleAdjust *= 2f;
+                    base.Texture = value;
+                }
+            }
+        }
     }
 }

osu.Game/Skinning/SkinManager.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Skinning
                     CurrentSkinInfo.Value = SkinInfo.Default;
             };
 
-            CurrentSkinInfo.ValueChanged += skin => CurrentSkin.Value = getSkin(skin.NewValue);
+            CurrentSkinInfo.ValueChanged += skin => CurrentSkin.Value = GetSkin(skin.NewValue);
             CurrentSkin.ValueChanged += skin =>
             {
                 if (skin.NewValue.SkinInfo != CurrentSkinInfo.Value)
@@ -80,7 +80,7 @@ namespace osu.Game.Skinning
         {
             await base.Populate(model, archive, cancellationToken);
 
-            Skin reference = getSkin(model);
+            Skin reference = GetSkin(model);
 
             if (!string.IsNullOrEmpty(reference.Configuration.SkinInfo.Name))
             {
@@ -99,7 +99,7 @@ namespace osu.Game.Skinning
         /// </summary>
         /// <param name="skinInfo">The skin to lookup.</param>
         /// <returns>A <see cref="Skin"/> instance correlating to the provided <see cref="SkinInfo"/>.</returns>
-        private Skin getSkin(SkinInfo skinInfo)
+        public Skin GetSkin(SkinInfo skinInfo)
         {
             if (skinInfo == SkinInfo.Default)
                 return new DefaultSkin();

osu.Game/Tests/Visual/OsuGridTestScene.cs

@@ -5,7 +5,7 @@ using osu.Framework.Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 
-namespace osu.Game.Tests.Visual.UserInterface
+namespace osu.Game.Tests.Visual
 {
     /// <summary>
     /// An abstract test case which exposes small cells arranged in a grid.

osu.Game/Tests/Visual/OsuTestScene.cs

@@ -15,6 +15,7 @@ using osu.Framework.Platform;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
+using osu.Game.Database;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Tests.Beatmaps;
@@ -43,6 +44,9 @@ namespace osu.Game.Tests.Visual
         private readonly Lazy<Storage> localStorage;
         protected Storage LocalStorage => localStorage.Value;
 
+        private readonly Lazy<DatabaseContextFactory> contextFactory;
+        protected DatabaseContextFactory ContextFactory => contextFactory.Value;
+
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
         {
             // This is the earliest we can get OsuGameBase, which is used by the dummy working beatmap to find textures
@@ -59,6 +63,14 @@ namespace osu.Game.Tests.Visual
         protected OsuTestScene()
         {
             localStorage = new Lazy<Storage>(() => new NativeStorage($"{GetType().Name}-{Guid.NewGuid()}"));
+            contextFactory = new Lazy<DatabaseContextFactory>(() =>
+            {
+                var factory = new DatabaseContextFactory(LocalStorage);
+                factory.ResetDatabase();
+                using (var usage = factory.Get())
+                    usage.Migrate();
+                return factory;
+            });
         }
 
         [Resolved]
@@ -85,6 +97,9 @@ namespace osu.Game.Tests.Visual
             if (beatmap?.Value.TrackLoaded == true)
                 beatmap.Value.Track.Stop();
 
+            if (contextFactory.IsValueCreated)
+                contextFactory.Value.ResetDatabase();
+
             if (localStorage.IsValueCreated)
             {
                 try

osu.Game/Users/User.cs

@@ -118,7 +118,7 @@ namespace osu.Game.Users
         public int PostCount;
 
         [JsonProperty(@"follower_count")]
-        public int[] FollowerCount;
+        public int FollowerCount;
 
         [JsonProperty]
         private string[] playstyle

osu.Game/Utils/RavenLogger.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Net;
 using System.Threading.Tasks;
 using osu.Framework.Logging;
 using SharpRaven;
@@ -36,31 +37,50 @@ namespace osu.Game.Utils
 
                 if (exception != null)
                 {
-                    if (exception is IOException ioe)
+                    if (!shouldSubmitException(exception))
-                    {
+                        return;
-                        // disk full exceptions, see https://stackoverflow.com/a/9294382
-                        const int hr_error_handle_disk_full = unchecked((int)0x80070027);
-                        const int hr_error_disk_full = unchecked((int)0x80070070);
-
-                        if (ioe.HResult == hr_error_handle_disk_full || ioe.HResult == hr_error_disk_full)
-                            return;
-                    }
 
                     // since we let unhandled exceptions go ignored at times, we want to ensure they don't get submitted on subsequent reports.
                     if (lastException != null &&
                         lastException.Message == exception.Message && exception.StackTrace.StartsWith(lastException.StackTrace))
-                    {
                         return;
-                    }
 
                     lastException = exception;
-                    queuePendingTask(raven.CaptureAsync(new SentryEvent(exception)));
+                    queuePendingTask(raven.CaptureAsync(new SentryEvent(exception) { Message = entry.Message }));
                 }
                 else
                     raven.AddTrail(new Breadcrumb(entry.Target.ToString(), BreadcrumbType.Navigation) { Message = entry.Message });
             };
         }
 
+        private bool shouldSubmitException(Exception exception)
+        {
+            switch (exception)
+            {
+                case IOException ioe:
+                    // disk full exceptions, see https://stackoverflow.com/a/9294382
+                    const int hr_error_handle_disk_full = unchecked((int)0x80070027);
+                    const int hr_error_disk_full = unchecked((int)0x80070070);
+
+                    if (ioe.HResult == hr_error_handle_disk_full || ioe.HResult == hr_error_disk_full)
+                        return false;
+
+                    break;
+
+                case WebException we:
+                    switch (we.Status)
+                    {
+                        // more statuses may need to be blocked as we come across them.
+                        case WebExceptionStatus.Timeout:
+                            return false;
+                    }
+
+                    break;
+            }
+
+            return true;
+        }
+
         private void queuePendingTask(Task<string> task)
         {
             lock (tasks) tasks.Add(task);

osu.Game/osu.Game.csproj

@@ -15,7 +15,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.4" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.702.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2019.729.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2019.730.0" />
     <PackageReference Include="SharpCompress" Version="0.23.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />

osu.iOS.props

@@ -105,8 +105,8 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.1" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2019.702.0" />
-    <PackageReference Include="ppy.osu.Framework" Version="2019.729.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2019.730.0" />
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2019.729.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2019.730.0" />
     <PackageReference Include="SharpCompress" Version="0.22.0" />
     <PackageReference Include="NUnit" Version="3.11.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />

osu.iOS/Info.plist

@@ -14,6 +14,8 @@
 	<string>0.1.0</string>
 	<key>LSRequiresIPhoneOS</key>
 	<true/>
+	<key>LSSupportsOpeningDocumentsInPlace</key>
+	<true/>
 	<key>MinimumOSVersion</key>
 	<string>10.0</string>
 	<key>UIDeviceFamily</key>