Merge branch 'master' into diffcalc/fix/clockrate-adjusted-decay

osu.Android.props

@@ -52,6 +52,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2021.211.1" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.323.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.330.0" />
   </ItemGroup>
 </Project>

osu.Android/osu.Android.csproj

@@ -53,5 +53,10 @@
   <ItemGroup>
     <AndroidResource Include="Resources\drawable\lazer.png" />
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Formats.Asn1">
+      <Version>5.0.0</Version>
+    </PackageReference>
+  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
 </Project>

osu.Desktop/OsuGameDesktop.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -18,6 +19,7 @@ using osu.Framework.Screens;
 using osu.Game.Screens.Menu;
 using osu.Game.Updater;
 using osu.Desktop.Windows;
+using osu.Framework.Threading;
 using osu.Game.IO;
 
 namespace osu.Desktop
@@ -144,13 +146,39 @@ namespace osu.Desktop
             desktopWindow.DragDrop += f => fileDrop(new[] { f });
         }
 
+        private readonly List<string> importableFiles = new List<string>();
+        private ScheduledDelegate importSchedule;
+
         private void fileDrop(string[] filePaths)
+        {
+            lock (importableFiles)
             {
                 var firstExtension = Path.GetExtension(filePaths.First());
 
                 if (filePaths.Any(f => Path.GetExtension(f) != firstExtension)) return;
 
-            Task.Factory.StartNew(() => Import(filePaths), TaskCreationOptions.LongRunning);
+                importableFiles.AddRange(filePaths);
+
+                Logger.Log($"Adding {filePaths.Length} files for import");
+
+                // File drag drop operations can potentially trigger hundreds or thousands of these calls on some platforms.
+                // In order to avoid spawning multiple import tasks for a single drop operation, debounce a touch.
+                importSchedule?.Cancel();
+                importSchedule = Scheduler.AddDelayed(handlePendingImports, 100);
+            }
+        }
+
+        private void handlePendingImports()
+        {
+            lock (importableFiles)
+            {
+                Logger.Log($"Handling batch import of {importableFiles.Count} files");
+
+                var paths = importableFiles.ToArray();
+                importableFiles.Clear();
+
+                Task.Factory.StartNew(() => Import(paths), TaskCreationOptions.LongRunning);
+            }
         }
     }
 }

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

@@ -35,5 +35,10 @@
       <Name>osu.Game</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Formats.Asn1">
+      <Version>5.0.0</Version>
+    </PackageReference>
+  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
 </Project>

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

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
     <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

osu.Game.Rulesets.Catch/Mods/CatchModHidden.cs

@@ -3,13 +3,16 @@
 
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawables;
+using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Catch.Mods
 {
-    public class CatchModHidden : ModHidden
+    public class CatchModHidden : ModHidden, IApplicableToDrawableRuleset<CatchHitObject>
     {
         public override string Description => @"Play with fading fruits.";
         public override double ScoreMultiplier => 1.06;
@@ -17,6 +20,14 @@ namespace osu.Game.Rulesets.Catch.Mods
         private const double fade_out_offset_multiplier = 0.6;
         private const double fade_out_duration_multiplier = 0.44;
 
+        public void ApplyToDrawableRuleset(DrawableRuleset<CatchHitObject> drawableRuleset)
+        {
+            var drawableCatchRuleset = (DrawableCatchRuleset)drawableRuleset;
+            var catchPlayfield = (CatchPlayfield)drawableCatchRuleset.Playfield;
+
+            catchPlayfield.CatcherArea.MovableCatcher.CatchFruitOnPlate = false;
+        }
+
         protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
             base.ApplyNormalVisibilityState(hitObject, state);

osu.Game.Rulesets.Catch/Skinning/Legacy/CatchLegacySkinTransformer.cs

@@ -5,7 +5,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Skinning;
 using osuTK.Graphics;
-using static osu.Game.Skinning.LegacySkinConfiguration;
 
 namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
@@ -14,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
         /// <summary>
         /// For simplicity, let's use legacy combo font texture existence as a way to identify legacy skins from default.
         /// </summary>
-        private bool providesComboCounter => this.HasFont(GetConfig<LegacySetting, string>(LegacySetting.ComboPrefix)?.Value ?? "score");
+        private bool providesComboCounter => this.HasFont(LegacyFont.Combo);
 
         public CatchLegacySkinTransformer(ISkinSource source)
             : base(source)
@@ -69,7 +68,6 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                            this.GetAnimation("fruit-ryuuta", true, true, true);
 
                 case CatchSkinComponents.CatchComboCounter:
-
                     if (providesComboCounter)
                         return new LegacyCatchComboCounter(Source);
 

osu.Game.Rulesets.Catch/Skinning/Legacy/LegacyCatchComboCounter.cs

@@ -7,7 +7,6 @@ using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Skinning;
 using osuTK;
 using osuTK.Graphics;
-using static osu.Game.Skinning.LegacySkinConfiguration;
 
 namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 {
@@ -22,9 +21,6 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 
         public LegacyCatchComboCounter(ISkin skin)
         {
-            var fontName = skin.GetConfig<LegacySetting, string>(LegacySetting.ComboPrefix)?.Value ?? "score";
-            var fontOverlap = skin.GetConfig<LegacySetting, float>(LegacySetting.ComboOverlap)?.Value ?? -2f;
-
             AutoSizeAxes = Axes.Both;
 
             Alpha = 0f;
@@ -34,7 +30,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
 
             InternalChildren = new Drawable[]
             {
-                explosion = new LegacyRollingCounter(skin, fontName, fontOverlap)
+                explosion = new LegacyRollingCounter(skin, LegacyFont.Combo)
                 {
                     Alpha = 0.65f,
                     Blending = BlendingParameters.Additive,
@@ -42,7 +38,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                     Origin = Anchor.Centre,
                     Scale = new Vector2(1.5f),
                 },
-                counter = new LegacyRollingCounter(skin, fontName, fontOverlap)
+                counter = new LegacyRollingCounter(skin, LegacyFont.Combo)
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,

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

@@ -43,6 +43,11 @@ namespace osu.Game.Rulesets.Catch.UI
         /// </summary>
         public bool HyperDashing => hyperDashModifier != 1;
 
+        /// <summary>
+        /// Whether <see cref="DrawablePalpableCatchHitObject"/> fruit should appear on the plate.
+        /// </summary>
+        public bool CatchFruitOnPlate { get; set; } = true;
+
         /// <summary>
         /// The relative space to cover in 1 millisecond. based on 1 game pixel per millisecond as in osu-stable.
         /// </summary>
@@ -237,6 +242,7 @@ namespace osu.Game.Rulesets.Catch.UI
             {
                 var positionInStack = computePositionInStack(new Vector2(palpableObject.X - X, 0), palpableObject.DisplaySize.X / 2);
 
+                if (CatchFruitOnPlate)
                     placeCaughtObject(palpableObject, positionInStack);
 
                 if (hitLighting.Value)

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

@@ -35,5 +35,10 @@
       <Name>osu.Game</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Formats.Asn1">
+      <Version>5.0.0</Version>
+    </PackageReference>
+  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
 </Project>

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

@@ -288,17 +288,56 @@ namespace osu.Game.Rulesets.Mania.Tests
                                                                        .All(j => j.Type.IsHit()));
         }
 
+        [Test]
+        public void TestHitTailBeforeLastTick()
+        {
+            const int tick_rate = 8;
+            const double tick_spacing = TimingControlPoint.DEFAULT_BEAT_LENGTH / tick_rate;
+            const double time_last_tick = time_head + tick_spacing * (int)((time_tail - time_head) / tick_spacing - 1);
+
+            var beatmap = new Beatmap<ManiaHitObject>
+            {
+                HitObjects =
+                {
+                    new HoldNote
+                    {
+                        StartTime = time_head,
+                        Duration = time_tail - time_head,
+                        Column = 0,
+                    }
+                },
+                BeatmapInfo =
+                {
+                    BaseDifficulty = new BeatmapDifficulty { SliderTickRate = tick_rate },
+                    Ruleset = new ManiaRuleset().RulesetInfo
+                },
+            };
+
+            performTest(new List<ReplayFrame>
+            {
+                new ManiaReplayFrame(time_head, ManiaAction.Key1),
+                new ManiaReplayFrame(time_last_tick - 5)
+            }, beatmap);
+
+            assertHeadJudgement(HitResult.Perfect);
+            assertLastTickJudgement(HitResult.LargeTickMiss);
+            assertTailJudgement(HitResult.Ok);
+        }
+
         private void assertHeadJudgement(HitResult result)
-            => AddAssert($"head judged as {result}", () => judgementResults[0].Type == result);
+            => AddAssert($"head judged as {result}", () => judgementResults.First(j => j.HitObject is Note).Type == result);
 
         private void assertTailJudgement(HitResult result)
-            => AddAssert($"tail judged as {result}", () => judgementResults[^2].Type == result);
+            => AddAssert($"tail judged as {result}", () => judgementResults.Single(j => j.HitObject is TailNote).Type == result);
 
         private void assertNoteJudgement(HitResult result)
-            => AddAssert($"hold note judged as {result}", () => judgementResults[^1].Type == result);
+            => AddAssert($"hold note judged as {result}", () => judgementResults.Single(j => j.HitObject is HoldNote).Type == result);
 
         private void assertTickJudgement(HitResult result)
-            => AddAssert($"tick judged as {result}", () => judgementResults[6].Type == result); // arbitrary tick
+            => AddAssert($"any tick judged as {result}", () => judgementResults.Where(j => j.HitObject is HoldNoteTick).Any(j => j.Type == result));
+
+        private void assertLastTickJudgement(HitResult result)
+            => AddAssert($"last tick judged as {result}", () => judgementResults.Last(j => j.HitObject is HoldNoteTick).Type == result);
 
         private ScoreAccessibleReplayPlayer currentPlayer;
 

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

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
     <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
             if (IsForCurrentRuleset)
             {
-                TargetColumns = (int)Math.Max(1, roundedCircleSize);
+                TargetColumns = GetColumnCountForNonConvert(beatmap.BeatmapInfo);
 
                 if (TargetColumns > ManiaRuleset.MAX_STAGE_KEYS)
                 {
@@ -71,6 +71,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             originalTargetColumns = TargetColumns;
         }
 
+        public static int GetColumnCountForNonConvert(BeatmapInfo beatmap)
+        {
+            var roundedCircleSize = Math.Round(beatmap.BaseDifficulty.CircleSize);
+            return (int)Math.Max(1, roundedCircleSize);
+        }
+
         public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition);
 
         protected override Beatmap<ManiaHitObject> ConvertBeatmap(IBeatmap original, CancellationToken cancellationToken)

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

@@ -119,5 +119,8 @@ namespace osu.Game.Rulesets.Mania.Edit
                     beatSnapGrid.SelectionTimeRange = null;
             }
         }
+
+        public override string ConvertSelectionToString()
+            => string.Join(',', EditorBeatmap.SelectedHitObjects.Cast<ManiaHitObject>().OrderBy(h => h.StartTime).Select(h => $"{h.StartTime}|{h.Column}"));
     }
 }

osu.Game.Rulesets.Mania/ManiaFilterCriteria.cs

@@ -0,0 +1,33 @@
+// 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.Beatmaps;
+using osu.Game.Rulesets.Filter;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Screens.Select;
+using osu.Game.Screens.Select.Filter;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class ManiaFilterCriteria : IRulesetFilterCriteria
+    {
+        private FilterCriteria.OptionalRange<float> keys;
+
+        public bool Matches(BeatmapInfo beatmap)
+        {
+            return !keys.HasFilter || (beatmap.RulesetID == new ManiaRuleset().LegacyID && keys.IsInRange(ManiaBeatmapConverter.GetColumnCountForNonConvert(beatmap)));
+        }
+
+        public bool TryParseCustomKeywordCriteria(string key, Operator op, string value)
+        {
+            switch (key)
+            {
+                case "key":
+                case "keys":
+                    return FilterQueryParser.TryUpdateCriteriaRange(ref keys, op, value);
+            }
+
+            return false;
+        }
+    }
+}

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -22,6 +22,7 @@ using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Filter;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Difficulty;
@@ -382,6 +383,11 @@ namespace osu.Game.Rulesets.Mania
                 }
             }
         };
+
+        public override IRulesetFilterCriteria CreateRulesetFilterCriteria()
+        {
+            return new ManiaFilterCriteria();
+        }
     }
 
     public enum PlayfieldType

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs

@@ -233,6 +233,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             if (Tail.AllJudged)
             {
+                foreach (var tick in tickContainer)
+                {
+                    if (!tick.Judged)
+                        tick.MissForcefully();
+                }
+
                 ApplyResult(r => r.Type = r.Judgement.MaxResult);
                 endHold();
             }

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

@@ -35,5 +35,10 @@
       <Name>osu.Game</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Formats.Asn1">
+      <Version>5.0.0</Version>
+    </PackageReference>
+  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
 </Project>

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

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
     <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -82,6 +82,9 @@ namespace osu.Game.Rulesets.Osu.Edit
         protected override ComposeBlueprintContainer CreateBlueprintContainer()
             => new OsuBlueprintContainer(this);
 
+        public override string ConvertSelectionToString()
+            => string.Join(',', selectedHitObjects.Cast<OsuHitObject>().OrderBy(h => h.StartTime).Select(h => (h.IndexInCurrentCombo + 1).ToString()));
+
         private DistanceSnapGrid distanceSnapGrid;
         private Container distanceSnapGridContainer;
 

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

@@ -35,8 +35,18 @@ namespace osu.Game.Rulesets.Osu.Edit
             referenceOrigin = null;
         }
 
-        public override bool HandleMovement(MoveSelectionEvent moveEvent) =>
+        public override bool HandleMovement(MoveSelectionEvent moveEvent)
-            moveSelection(moveEvent.InstantDelta);
+        {
+            var hitObjects = selectedMovableObjects;
+
+            // this will potentially move the selection out of bounds...
+            foreach (var h in hitObjects)
+                h.Position += moveEvent.InstantDelta;
+
+            // but this will be corrected.
+            moveSelectionInBounds();
+            return true;
+        }
 
         /// <summary>
         /// During a transform, the initial origin is stored so it can be used throughout the operation.
@@ -140,36 +150,11 @@ namespace osu.Game.Rulesets.Osu.Edit
             // the only hit object selected. with a group selection, it's likely the user
             // is not looking to change the duration of the slider but expand the whole pattern.
             if (hitObjects.Length == 1 && hitObjects.First() is Slider slider)
-            {
+                scaleSlider(slider, scale);
-                Quad quad = getSurroundingQuad(slider.Path.ControlPoints.Select(p => p.Position.Value));
-                Vector2 pathRelativeDeltaScale = new Vector2(1 + scale.X / quad.Width, 1 + scale.Y / quad.Height);
-
-                foreach (var point in slider.Path.ControlPoints)
-                    point.Position.Value *= pathRelativeDeltaScale;
-            }
             else
-            {
+                scaleHitObjects(hitObjects, reference, scale);
-                // move the selection before scaling if dragging from top or left anchors.
-                if ((reference & Anchor.x0) > 0 && !moveSelection(new Vector2(-scale.X, 0))) return false;
-                if ((reference & Anchor.y0) > 0 && !moveSelection(new Vector2(0, -scale.Y))) return false;
-
-                Quad quad = getSurroundingQuad(hitObjects);
-
-                foreach (var h in hitObjects)
-                {
-                    var newPosition = h.Position;
-
-                    // guard against no-ops and NaN.
-                    if (scale.X != 0 && quad.Width > 0)
-                        newPosition.X = quad.TopLeft.X + (h.X - quad.TopLeft.X) / quad.Width * (quad.Width + scale.X);
-
-                    if (scale.Y != 0 && quad.Height > 0)
-                        newPosition.Y = quad.TopLeft.Y + (h.Y - quad.TopLeft.Y) / quad.Height * (quad.Height + scale.Y);
-
-                    h.Position = newPosition;
-                }
-            }
 
+            moveSelectionInBounds();
             return true;
         }
 
@@ -207,28 +192,124 @@ namespace osu.Game.Rulesets.Osu.Edit
             return true;
         }
 
-        private bool moveSelection(Vector2 delta)
+        private void scaleSlider(Slider slider, Vector2 scale)
+        {
+            Quad sliderQuad = getSurroundingQuad(slider.Path.ControlPoints.Select(p => p.Position.Value));
+
+            // Limit minimum distance between control points  after scaling to almost 0. Less than 0 causes the slider to flip, exactly 0 causes a crash through division by 0.
+            scale = Vector2.ComponentMax(new Vector2(Precision.FLOAT_EPSILON), sliderQuad.Size + scale) - sliderQuad.Size;
+
+            Vector2 pathRelativeDeltaScale = new Vector2(1 + scale.X / sliderQuad.Width, 1 + scale.Y / sliderQuad.Height);
+
+            Queue<Vector2> oldControlPoints = new Queue<Vector2>();
+
+            foreach (var point in slider.Path.ControlPoints)
+            {
+                oldControlPoints.Enqueue(point.Position.Value);
+                point.Position.Value *= pathRelativeDeltaScale;
+            }
+
+            //if sliderhead or sliderend end up outside playfield, revert scaling.
+            Quad scaledQuad = getSurroundingQuad(new OsuHitObject[] { slider });
+            (bool xInBounds, bool yInBounds) = isQuadInBounds(scaledQuad);
+
+            if (xInBounds && yInBounds)
+                return;
+
+            foreach (var point in slider.Path.ControlPoints)
+                point.Position.Value = oldControlPoints.Dequeue();
+        }
+
+        private void scaleHitObjects(OsuHitObject[] hitObjects, Anchor reference, Vector2 scale)
+        {
+            scale = getClampedScale(hitObjects, reference, scale);
+
+            // move the selection before scaling if dragging from top or left anchors.
+            float xOffset = ((reference & Anchor.x0) > 0) ? -scale.X : 0;
+            float yOffset = ((reference & Anchor.y0) > 0) ? -scale.Y : 0;
+
+            Quad selectionQuad = getSurroundingQuad(hitObjects);
+
+            foreach (var h in hitObjects)
+            {
+                var newPosition = h.Position;
+
+                // guard against no-ops and NaN.
+                if (scale.X != 0 && selectionQuad.Width > 0)
+                    newPosition.X = selectionQuad.TopLeft.X + xOffset + (h.X - selectionQuad.TopLeft.X) / selectionQuad.Width * (selectionQuad.Width + scale.X);
+
+                if (scale.Y != 0 && selectionQuad.Height > 0)
+                    newPosition.Y = selectionQuad.TopLeft.Y + yOffset + (h.Y - selectionQuad.TopLeft.Y) / selectionQuad.Height * (selectionQuad.Height + scale.Y);
+
+                h.Position = newPosition;
+            }
+        }
+
+        private (bool X, bool Y) isQuadInBounds(Quad quad)
+        {
+            bool xInBounds = (quad.TopLeft.X >= 0) && (quad.BottomRight.X <= DrawWidth);
+            bool yInBounds = (quad.TopLeft.Y >= 0) && (quad.BottomRight.Y <= DrawHeight);
+
+            return (xInBounds, yInBounds);
+        }
+
+        private void moveSelectionInBounds()
         {
             var hitObjects = selectedMovableObjects;
 
             Quad quad = getSurroundingQuad(hitObjects);
 
-            Vector2 newTopLeft = quad.TopLeft + delta;
+            Vector2 delta = Vector2.Zero;
-            if (newTopLeft.X < 0)
-                delta.X -= newTopLeft.X;
-            if (newTopLeft.Y < 0)
-                delta.Y -= newTopLeft.Y;
 
-            Vector2 newBottomRight = quad.BottomRight + delta;
+            if (quad.TopLeft.X < 0)
-            if (newBottomRight.X > DrawWidth)
+                delta.X -= quad.TopLeft.X;
-                delta.X -= newBottomRight.X - DrawWidth;
+            if (quad.TopLeft.Y < 0)
-            if (newBottomRight.Y > DrawHeight)
+                delta.Y -= quad.TopLeft.Y;
-                delta.Y -= newBottomRight.Y - DrawHeight;
+
+            if (quad.BottomRight.X > DrawWidth)
+                delta.X -= quad.BottomRight.X - DrawWidth;
+            if (quad.BottomRight.Y > DrawHeight)
+                delta.Y -= quad.BottomRight.Y - DrawHeight;
 
             foreach (var h in hitObjects)
                 h.Position += delta;
+        }
 
-            return true;
+        /// <summary>
+        /// Clamp scale for multi-object-scaling where selection does not exceed playfield bounds or flip.
+        /// </summary>
+        /// <param name="hitObjects">The hitobjects to be scaled</param>
+        /// <param name="reference">The anchor from which the scale operation is performed</param>
+        /// <param name="scale">The scale to be clamped</param>
+        /// <returns>The clamped scale vector</returns>
+        private Vector2 getClampedScale(OsuHitObject[] hitObjects, Anchor reference, Vector2 scale)
+        {
+            float xOffset = ((reference & Anchor.x0) > 0) ? -scale.X : 0;
+            float yOffset = ((reference & Anchor.y0) > 0) ? -scale.Y : 0;
+
+            Quad selectionQuad = getSurroundingQuad(hitObjects);
+
+            //todo: this is not always correct for selections involving sliders. This approximation assumes each point is scaled independently, but sliderends move with the sliderhead.
+            Quad scaledQuad = new Quad(selectionQuad.TopLeft.X + xOffset, selectionQuad.TopLeft.Y + yOffset, selectionQuad.Width + scale.X, selectionQuad.Height + scale.Y);
+
+            //max Size -> playfield bounds
+            if (scaledQuad.TopLeft.X < 0)
+                scale.X += scaledQuad.TopLeft.X;
+            if (scaledQuad.TopLeft.Y < 0)
+                scale.Y += scaledQuad.TopLeft.Y;
+
+            if (scaledQuad.BottomRight.X > DrawWidth)
+                scale.X -= scaledQuad.BottomRight.X - DrawWidth;
+            if (scaledQuad.BottomRight.Y > DrawHeight)
+                scale.Y -= scaledQuad.BottomRight.Y - DrawHeight;
+
+            //min Size -> almost 0. Less than 0 causes the quad to flip, exactly 0 causes scaling to get stuck at minimum scale.
+            Vector2 scaledSize = selectionQuad.Size + scale;
+            Vector2 minSize = new Vector2(Precision.FLOAT_EPSILON);
+
+            scale = Vector2.ComponentMax(minSize, scaledSize) - selectionQuad.Size;
+
+            return scale;
         }
 
         /// <summary>

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

@@ -44,6 +44,9 @@ namespace osu.Game.Rulesets.Osu.Mods
         [SettingSource("Use fixed slider follow circle hit area", "Makes the slider follow circle track its final size at all times.")]
         public Bindable<bool> FixedFollowCircleHitArea { get; } = new BindableBool(true);
 
+        [SettingSource("Always play a slider's tail sample", "Always plays a slider's tail sample regardless of whether it was hit or not.")]
+        public Bindable<bool> AlwaysPlayTailSample { get; } = new BindableBool(true);
+
         public void ApplyToHitObject(HitObject hitObject)
         {
             switch (hitObject)
@@ -79,6 +82,10 @@ namespace osu.Game.Rulesets.Osu.Mods
                     case DrawableSliderHead head:
                         head.TrackFollowCircle = !NoSliderHeadMovement.Value;
                         break;
+
+                    case DrawableSliderTail tail:
+                        tail.SamplePlaysOnlyOnHit = !AlwaysPlayTailSample.Value;
+                        break;
                 }
             }
         }

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

@@ -280,7 +280,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             // rather than doing it this way, we should probably attach the sample to the tail circle.
             // this can only be done after we stop using LegacyLastTick.
-            if (TailCircle.IsHit)
+            if (!TailCircle.SamplePlaysOnlyOnHit || TailCircle.IsHit)
                 base.PlaySamples();
         }
 

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

@@ -26,6 +26,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         /// </summary>
         public override bool DisplayResult => false;
 
+        /// <summary>
+        /// Whether the hit samples only play on successful hits.
+        /// If <c>false</c>, the hit samples will also play on misses.
+        /// </summary>
+        public bool SamplePlaysOnlyOnHit { get; set; } = true;
+
         public bool Tracking { get; set; }
 
         private SkinnableDrawable circlePiece;

osu.Game.Rulesets.Osu/Skinning/Legacy/LegacySpinner.cs

@@ -48,9 +48,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
             DrawableSpinner = (DrawableSpinner)drawableHitObject;
 
-            Container overlayContainer;
+            AddInternal(new Container
-
-            AddInternal(overlayContainer = new Container
             {
                 Depth = float.MinValue,
                 RelativeSizeAxes = Axes.Both,
@@ -73,21 +71,16 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                         Scale = new Vector2(SPRITE_SCALE),
                         Y = SPINNER_TOP_OFFSET + 115,
                     },
+                    bonusCounter = new LegacySpriteText(source, LegacyFont.Score)
+                    {
+                        Alpha = 0f,
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.Centre,
+                        Scale = new Vector2(SPRITE_SCALE),
+                        Y = SPINNER_TOP_OFFSET + 299,
+                    }.With(s => s.Font = s.Font.With(fixedWidth: false)),
                 }
             });
-
-            bonusCounter = (source.GetDrawableComponent(new HUDSkinComponent(HUDSkinComponents.ScoreText)) as LegacySpriteText)?.With(c =>
-            {
-                c.Alpha = 0f;
-                c.Anchor = Anchor.TopCentre;
-                c.Origin = Anchor.Centre;
-                c.Font = c.Font.With(fixedWidth: false);
-                c.Scale = new Vector2(SPRITE_SCALE);
-                c.Y = SPINNER_TOP_OFFSET + 299;
-            });
-
-            if (bonusCounter != null)
-                overlayContainer.Add(bonusCounter);
         }
 
         private IBindable<double> gainedBonus;
@@ -98,8 +91,6 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
         {
             base.LoadComplete();
 
-            if (bonusCounter != null)
-            {
             gainedBonus = DrawableSpinner.GainedBonus.GetBoundCopy();
             gainedBonus.BindValueChanged(bonus =>
             {
@@ -107,7 +98,6 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                 bonusCounter.FadeOutFromOne(800, Easing.Out);
                 bonusCounter.ScaleTo(SPRITE_SCALE * 2f).Then().ScaleTo(SPRITE_SCALE * 1.28f, 800, Easing.Out);
             });
-            }
 
             completed.BindValueChanged(onCompletedChanged, true);
 

osu.Game.Rulesets.Osu/Skinning/Legacy/OsuLegacySkinTransformer.cs

@@ -97,16 +97,13 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
                     return null;
 
                 case OsuSkinComponents.HitCircleText:
-                    var font = GetConfig<OsuSkinConfiguration, string>(OsuSkinConfiguration.HitCirclePrefix)?.Value ?? "default";
+                    if (!this.HasFont(LegacyFont.HitCircle))
-                    var overlap = GetConfig<OsuSkinConfiguration, float>(OsuSkinConfiguration.HitCircleOverlap)?.Value ?? -2;
+                        return null;
 
-                    return !this.HasFont(font)
+                    return new LegacySpriteText(Source, LegacyFont.HitCircle)
-                        ? null
-                        : new LegacySpriteText(Source, font)
                     {
                         // stable applies a blanket 0.8x scale to hitcircle fonts
                         Scale = new Vector2(0.8f),
-                            Spacing = new Vector2(-overlap, 0)
                     };
 
                 case OsuSkinComponents.SpinnerBody:

osu.Game.Rulesets.Osu/Skinning/OsuSkinConfiguration.cs

@@ -5,8 +5,6 @@ namespace osu.Game.Rulesets.Osu.Skinning
 {
     public enum OsuSkinConfiguration
     {
-        HitCirclePrefix,
-        HitCircleOverlap,
         SliderBorderSize,
         SliderPathRadius,
         AllowSliderBallTint,

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

@@ -35,5 +35,10 @@
       <Name>osu.Game</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Formats.Asn1">
+      <Version>5.0.0</Version>
+    </PackageReference>
+  </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
 </Project>

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

@@ -2,7 +2,7 @@
   <Import Project="..\osu.TestProject.props" />
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
     <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

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

@@ -75,6 +75,9 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="DeepEqual" Version="2.0.0" />
     <PackageReference Include="Moq" Version="4.16.1" />
+    <PackageReference Include="System.Formats.Asn1">
+      <Version>5.0.0</Version>
+    </PackageReference>
   </ItemGroup>
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
 </Project>

osu.Game.Tests/NonVisual/FormatUtilsTest.cs

@@ -0,0 +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.Globalization;
+using NUnit.Framework;
+using osu.Game.Utils;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [TestFixture]
+    public class FormatUtilsTest
+    {
+        [TestCase(0, "0.00%")]
+        [TestCase(0.01, "1.00%")]
+        [TestCase(0.9899, "98.99%")]
+        [TestCase(0.989999, "98.99%")]
+        [TestCase(0.99, "99.00%")]
+        [TestCase(0.9999, "99.99%")]
+        [TestCase(0.999999, "99.99%")]
+        [TestCase(1, "100.00%")]
+        public void TestAccuracyFormatting(double input, string expectedOutput)
+        {
+            Assert.AreEqual(expectedOutput, input.FormatAccuracy(CultureInfo.InvariantCulture));
+        }
+    }
+}

osu.Game.Tests/Online/TestAPIModJsonSerialization.cs

@@ -25,7 +25,7 @@ namespace osu.Game.Tests.Online
 
             var deserialized = JsonConvert.DeserializeObject<APIMod>(JsonConvert.SerializeObject(apiMod));
 
-            Assert.That(deserialized.Acronym, Is.EqualTo(apiMod.Acronym));
+            Assert.That(deserialized?.Acronym, Is.EqualTo(apiMod.Acronym));
         }
 
         [Test]
@@ -35,7 +35,7 @@ namespace osu.Game.Tests.Online
 
             var deserialized = JsonConvert.DeserializeObject<APIMod>(JsonConvert.SerializeObject(apiMod));
 
-            Assert.That(deserialized.Settings, Contains.Key("test_setting").With.ContainValue(2.0));
+            Assert.That(deserialized?.Settings, Contains.Key("test_setting").With.ContainValue(2.0));
         }
 
         [Test]
@@ -44,9 +44,9 @@ namespace osu.Game.Tests.Online
             var apiMod = new APIMod(new TestMod { TestSetting = { Value = 2 } });
 
             var deserialized = JsonConvert.DeserializeObject<APIMod>(JsonConvert.SerializeObject(apiMod));
-            var converted = (TestMod)deserialized.ToMod(new TestRuleset());
+            var converted = (TestMod)deserialized?.ToMod(new TestRuleset());
 
-            Assert.That(converted.TestSetting.Value, Is.EqualTo(2));
+            Assert.That(converted?.TestSetting.Value, Is.EqualTo(2));
         }
 
         [Test]
@@ -61,11 +61,11 @@ namespace osu.Game.Tests.Online
             });
 
             var deserialised = JsonConvert.DeserializeObject<APIMod>(JsonConvert.SerializeObject(apiMod));
-            var converted = (TestModTimeRamp)deserialised.ToMod(new TestRuleset());
+            var converted = (TestModTimeRamp)deserialised?.ToMod(new TestRuleset());
 
-            Assert.That(converted.AdjustPitch.Value, Is.EqualTo(false));
+            Assert.That(converted?.AdjustPitch.Value, Is.EqualTo(false));
-            Assert.That(converted.InitialRate.Value, Is.EqualTo(1.25));
+            Assert.That(converted?.InitialRate.Value, Is.EqualTo(1.25));
-            Assert.That(converted.FinalRate.Value, Is.EqualTo(0.25));
+            Assert.That(converted?.FinalRate.Value, Is.EqualTo(0.25));
         }
 
         [Test]
@@ -78,10 +78,10 @@ namespace osu.Game.Tests.Online
             });
 
             var deserialised = JsonConvert.DeserializeObject<APIMod>(JsonConvert.SerializeObject(apiMod));
-            var converted = (TestModDifficultyAdjust)deserialised.ToMod(new TestRuleset());
+            var converted = (TestModDifficultyAdjust)deserialised?.ToMod(new TestRuleset());
 
-            Assert.That(converted.ExtendedLimits.Value, Is.True);
+            Assert.That(converted?.ExtendedLimits.Value, Is.True);
-            Assert.That(converted.OverallDifficulty.Value, Is.EqualTo(11));
+            Assert.That(converted?.OverallDifficulty.Value, Is.EqualTo(11));
         }
 
         private class TestRuleset : Ruleset

osu.Game.Tests/Visual/Navigation/TestSceneScreenNavigation.cs

@@ -43,6 +43,29 @@ namespace osu.Game.Tests.Visual.Navigation
             exitViaEscapeAndConfirm();
         }
 
+        [Test]
+        public void TestRetryCountIncrements()
+        {
+            Player player = null;
+
+            PushAndConfirm(() => new TestSongSelect());
+
+            AddStep("import beatmap", () => ImportBeatmapTest.LoadQuickOszIntoOsu(Game).Wait());
+
+            AddUntilStep("wait for selected", () => !Game.Beatmap.IsDefault);
+
+            AddStep("press enter", () => InputManager.Key(Key.Enter));
+
+            AddUntilStep("wait for player", () => (player = Game.ScreenStack.CurrentScreen as Player) != null);
+            AddAssert("retry count is 0", () => player.RestartCount == 0);
+
+            AddStep("attempt to retry", () => player.ChildrenOfType<HotkeyRetryOverlay>().First().Action());
+            AddUntilStep("wait for old player gone", () => Game.ScreenStack.CurrentScreen != player);
+
+            AddUntilStep("get new player", () => (player = Game.ScreenStack.CurrentScreen as Player) != null);
+            AddAssert("retry count is 1", () => player.RestartCount == 1);
+        }
+
         [Test]
         public void TestRetryFromResults()
         {

osu.Game.Tests/Visual/Settings/TestSceneTabletSettings.cs

@@ -45,6 +45,8 @@ namespace osu.Game.Tests.Visual.Settings
             public Bindable<Vector2> AreaOffset { get; } = new Bindable<Vector2>();
             public Bindable<Vector2> AreaSize { get; } = new Bindable<Vector2>();
 
+            public Bindable<float> Rotation { get; } = new Bindable<float>();
+
             public IBindable<TabletInfo> Tablet => tablet;
 
             private readonly Bindable<TabletInfo> tablet = new Bindable<TabletInfo>();

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

@@ -3,7 +3,7 @@
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="DeepEqual" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
     <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />

osu.Game.Tournament.Tests/NonVisual/IPCLocationTest.cs

@@ -0,0 +1,73 @@
+// 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.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Platform;
+using osu.Game.Tournament.IO;
+using osu.Game.Tournament.IPC;
+
+namespace osu.Game.Tournament.Tests.NonVisual
+{
+    [TestFixture]
+    public class IPCLocationTest
+    {
+        [Test]
+        public void CheckIPCLocation()
+        {
+            // don't use clean run because files are being written before osu! launches.
+            using (HeadlessGameHost host = new HeadlessGameHost(nameof(CheckIPCLocation)))
+            {
+                string basePath = Path.Combine(RuntimeInfo.StartupDirectory, "headless", nameof(CheckIPCLocation));
+
+                // Set up a fake IPC client for the IPC Storage to switch to.
+                string testStableInstallDirectory = Path.Combine(basePath, "stable-ce");
+                Directory.CreateDirectory(testStableInstallDirectory);
+
+                string ipcFile = Path.Combine(testStableInstallDirectory, "ipc.txt");
+                File.WriteAllText(ipcFile, string.Empty);
+
+                try
+                {
+                    var osu = loadOsu(host);
+                    TournamentStorage storage = (TournamentStorage)osu.Dependencies.Get<Storage>();
+                    FileBasedIPC ipc = null;
+
+                    waitForOrAssert(() => (ipc = osu.Dependencies.Get<MatchIPCInfo>() as FileBasedIPC) != null, @"ipc could not be populated in a reasonable amount of time");
+
+                    Assert.True(ipc.SetIPCLocation(testStableInstallDirectory));
+                    Assert.True(storage.AllTournaments.Exists("stable.json"));
+                }
+                finally
+                {
+                    host.Storage.DeleteDirectory(testStableInstallDirectory);
+                    host.Storage.DeleteDirectory("tournaments");
+                    host.Exit();
+                }
+            }
+        }
+
+        private TournamentGameBase loadOsu(GameHost host)
+        {
+            var osu = new TournamentGameBase();
+            Task.Run(() => host.Run(osu));
+            waitForOrAssert(() => osu.IsLoaded, @"osu! failed to start in a reasonable amount of time");
+            return osu;
+        }
+
+        private static void waitForOrAssert(Func<bool> result, string failureMessage, int timeout = 90000)
+        {
+            Task task = Task.Run(() =>
+            {
+                while (!result()) Thread.Sleep(200);
+            });
+
+            Assert.IsTrue(task.Wait(timeout), failureMessage);
+        }
+    }
+}

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

@@ -5,7 +5,7 @@
   </PropertyGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
     <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
   </ItemGroup>

osu.Game.Tournament/IO/TournamentStorage.cs

@@ -1,12 +1,12 @@
 // 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.Collections.Generic;
+using System.IO;
 using osu.Framework.Bindables;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Game.IO;
-using System.IO;
-using System.Collections.Generic;
 using osu.Game.Tournament.Configuration;
 
 namespace osu.Game.Tournament.IO
@@ -15,7 +15,12 @@ namespace osu.Game.Tournament.IO
     {
         private const string default_tournament = "default";
         private readonly Storage storage;
-        private readonly Storage allTournaments;
+
+        /// <summary>
+        /// The storage where all tournaments are located.
+        /// </summary>
+        public readonly Storage AllTournaments;
+
         private readonly TournamentStorageManager storageConfig;
         public readonly Bindable<string> CurrentTournament;
 
@@ -23,16 +28,16 @@ namespace osu.Game.Tournament.IO
             : base(storage.GetStorageForDirectory("tournaments"), string.Empty)
         {
             this.storage = storage;
-            allTournaments = UnderlyingStorage;
+            AllTournaments = UnderlyingStorage;
 
             storageConfig = new TournamentStorageManager(storage);
 
             if (storage.Exists("tournament.ini"))
             {
-                ChangeTargetStorage(allTournaments.GetStorageForDirectory(storageConfig.Get<string>(StorageConfig.CurrentTournament)));
+                ChangeTargetStorage(AllTournaments.GetStorageForDirectory(storageConfig.Get<string>(StorageConfig.CurrentTournament)));
             }
             else
-                Migrate(allTournaments.GetStorageForDirectory(default_tournament));
+                Migrate(AllTournaments.GetStorageForDirectory(default_tournament));
 
             CurrentTournament = storageConfig.GetBindable<string>(StorageConfig.CurrentTournament);
             Logger.Log("Using tournament storage: " + GetFullPath(string.Empty));
@@ -42,11 +47,11 @@ namespace osu.Game.Tournament.IO
 
         private void updateTournament(ValueChangedEvent<string> newTournament)
         {
-            ChangeTargetStorage(allTournaments.GetStorageForDirectory(newTournament.NewValue));
+            ChangeTargetStorage(AllTournaments.GetStorageForDirectory(newTournament.NewValue));
             Logger.Log("Changing tournament storage: " + GetFullPath(string.Empty));
         }
 
-        public IEnumerable<string> ListTournaments() => allTournaments.GetDirectories(string.Empty);
+        public IEnumerable<string> ListTournaments() => AllTournaments.GetDirectories(string.Empty);
 
         public override void Migrate(Storage newStorage)
         {

osu.Game.Tournament/Models/StableInfo.cs

@@ -5,6 +5,7 @@ using System;
 using System.IO;
 using Newtonsoft.Json;
 using osu.Framework.Platform;
+using osu.Game.Tournament.IO;
 
 namespace osu.Game.Tournament.Models
 {
@@ -24,13 +25,14 @@ namespace osu.Game.Tournament.Models
         /// </summary>
         public event Action OnStableInfoSaved;
 
-        private const string config_path = "tournament/stable.json";
+        private const string config_path = "stable.json";
 
         private readonly Storage storage;
 
         public StableInfo(Storage storage)
         {
-            this.storage = storage;
+            TournamentStorage tStorage = (TournamentStorage)storage;
+            this.storage = tStorage.AllTournaments;
 
             if (!storage.Exists(config_path))
                 return;

osu.Game.Tournament/Screens/Editors/TeamEditorScreen.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using Newtonsoft.Json;
@@ -43,10 +44,13 @@ namespace osu.Game.Tournament.Screens.Editors
         private void addAllCountries()
         {
             List<TournamentTeam> countries;
+
             using (Stream stream = game.Resources.GetStream("Resources/countries.json"))
             using (var sr = new StreamReader(stream))
                 countries = JsonConvert.DeserializeObject<List<TournamentTeam>>(sr.ReadToEnd());
 
+            Debug.Assert(countries != null);
+
             foreach (var c in countries)
                 Storage.Add(c);
         }

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -147,7 +147,7 @@ namespace osu.Game.Beatmaps
         {
             string version = string.IsNullOrEmpty(Version) ? string.Empty : $"[{Version}]";
 
-            return $"{Metadata} {version}".Trim();
+            return $"{Metadata ?? BeatmapSet?.Metadata} {version}".Trim();
         }
 
         public bool Equals(BeatmapInfo other)

osu.Game/Input/Handlers/ReplayInputHandler.cs

@@ -34,8 +34,6 @@ namespace osu.Game.Input.Handlers
 
         public override bool IsActive => true;
 
-        public override int Priority => 0;
-
         public class ReplayState<T> : IInput
             where T : struct
         {

osu.Game/Online/DownloadTrackingComposite.cs

@@ -123,13 +123,13 @@ namespace osu.Game.Online
             {
                 if (attachedRequest.Progress == 1)
                 {
-                    State.Value = DownloadState.Importing;
                     Progress.Value = 1;
+                    State.Value = DownloadState.Importing;
                 }
                 else
                 {
-                    State.Value = DownloadState.Downloading;
                     Progress.Value = attachedRequest.Progress;
+                    State.Value = DownloadState.Downloading;
 
                     attachedRequest.Failure += onRequestFailure;
                     attachedRequest.DownloadProgressed += onRequestProgress;

osu.Game/Online/Leaderboards/LeaderboardScore.cs

@@ -61,6 +61,9 @@ namespace osu.Game.Online.Leaderboards
         [Resolved(CanBeNull = true)]
         private SongSelect songSelect { get; set; }
 
+        [Resolved]
+        private ScoreManager scoreManager { get; set; }
+
         public LeaderboardScore(ScoreInfo score, int? rank, bool allowHighlight = true)
         {
             this.score = score;
@@ -388,6 +391,9 @@ namespace osu.Game.Online.Leaderboards
                 if (score.Mods.Length > 0 && modsContainer.Any(s => s.IsHovered) && songSelect != null)
                     items.Add(new OsuMenuItem("Use these mods", MenuItemType.Highlighted, () => songSelect.Mods.Value = score.Mods));
 
+                if (score.Files.Count > 0)
+                    items.Add(new OsuMenuItem("Export", MenuItemType.Standard, () => scoreManager.Export(score)));
+
                 if (score.ID != 0)
                     items.Add(new OsuMenuItem("Delete", MenuItemType.Destructive, () => dialogOverlay?.Push(new LocalScoreDeleteDialog(score))));
 

osu.Game/Online/Rooms/OnlinePlayBeatmapAvailablilityTracker.cs

@@ -45,6 +45,9 @@ namespace osu.Game.Online.Rooms
 
             Progress.BindValueChanged(_ =>
             {
+                if (State.Value != DownloadState.Downloading)
+                    return;
+
                 // incoming progress changes are going to be at a very high rate.
                 // we don't want to flood the network with this, so rate limit how often we send progress updates.
                 if (progressUpdate?.Completed != false)

osu.Game/OsuGameBase.cs

@@ -429,6 +429,9 @@ namespace osu.Game
 
         public async Task Import(params string[] paths)
         {
+            if (paths.Length == 0)
+                return;
+
             var extension = Path.GetExtension(paths.First())?.ToLowerInvariant();
 
             foreach (var importer in fileImporters)

osu.Game/Overlays/Chat/DrawableChannel.cs

@@ -275,6 +275,7 @@ namespace osu.Game.Overlays.Chat
                     {
                         if (!UserScrolling)
                         {
+                            if (Current < ScrollableExtent)
                                 ScrollToEnd();
                             lastExtent = ScrollableExtent;
                         }

osu.Game/Overlays/Settings/Sections/Input/RotationPresetButtons.cs

@@ -0,0 +1,109 @@
+// 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.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Handlers.Tablet;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+
+namespace osu.Game.Overlays.Settings.Sections.Input
+{
+    internal class RotationPresetButtons : FillFlowContainer
+    {
+        private readonly ITabletHandler tabletHandler;
+
+        private Bindable<float> rotation;
+
+        private const int height = 50;
+
+        public RotationPresetButtons(ITabletHandler tabletHandler)
+        {
+            this.tabletHandler = tabletHandler;
+
+            RelativeSizeAxes = Axes.X;
+            Height = height;
+
+            for (int i = 0; i < 360; i += 90)
+            {
+                var presetRotation = i;
+
+                Add(new RotationButton(i)
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = height,
+                    Width = 0.25f,
+                    Text = $"{presetRotation}º",
+                    Action = () => tabletHandler.Rotation.Value = presetRotation,
+                });
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            rotation = tabletHandler.Rotation.GetBoundCopy();
+            rotation.BindValueChanged(val =>
+            {
+                foreach (var b in Children.OfType<RotationButton>())
+                    b.IsSelected = b.Preset == val.NewValue;
+            }, true);
+        }
+
+        public class RotationButton : TriangleButton
+        {
+            [Resolved]
+            private OsuColour colours { get; set; }
+
+            public readonly int Preset;
+
+            public RotationButton(int preset)
+            {
+                Preset = preset;
+            }
+
+            private bool isSelected;
+
+            public bool IsSelected
+            {
+                get => isSelected;
+                set
+                {
+                    if (value == isSelected)
+                        return;
+
+                    isSelected = value;
+
+                    if (IsLoaded)
+                        updateColour();
+                }
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                updateColour();
+            }
+
+            private void updateColour()
+            {
+                if (isSelected)
+                {
+                    BackgroundColour = colours.BlueDark;
+                    Triangles.ColourDark = colours.BlueDarker;
+                    Triangles.ColourLight = colours.Blue;
+                }
+                else
+                {
+                    BackgroundColour = colours.Gray4;
+                    Triangles.ColourDark = colours.Gray5;
+                    Triangles.ColourLight = colours.Gray6;
+                }
+            }
+        }
+    }
+}

osu.Game/Overlays/Settings/Sections/Input/TabletAreaSelection.cs

@@ -25,6 +25,8 @@ namespace osu.Game.Overlays.Settings.Sections.Input
         private readonly Bindable<Vector2> areaOffset = new Bindable<Vector2>();
         private readonly Bindable<Vector2> areaSize = new Bindable<Vector2>();
 
+        private readonly BindableNumber<float> rotation = new BindableNumber<float>();
+
         private readonly IBindable<TabletInfo> tablet = new Bindable<TabletInfo>();
 
         private OsuSpriteText tabletName;
@@ -124,6 +126,13 @@ namespace osu.Game.Overlays.Settings.Sections.Input
                 usableAreaText.Text = $"{(float)x / commonDivider}:{(float)y / commonDivider}";
             }, true);
 
+            rotation.BindTo(handler.Rotation);
+            rotation.BindValueChanged(val =>
+            {
+                usableAreaContainer.RotateTo(val.NewValue, 100, Easing.OutQuint)
+                                   .OnComplete(_ => checkBounds()); // required as we are using SSDQ.
+            });
+
             tablet.BindTo(handler.Tablet);
             tablet.BindValueChanged(_ => Scheduler.AddOnce(updateTabletDetails));
 

osu.Game/Overlays/Settings/Sections/Input/TabletSettings.cs

@@ -27,6 +27,8 @@ namespace osu.Game.Overlays.Settings.Sections.Input
         private readonly BindableNumber<float> sizeX = new BindableNumber<float> { MinValue = 10 };
         private readonly BindableNumber<float> sizeY = new BindableNumber<float> { MinValue = 10 };
 
+        private readonly BindableNumber<float> rotation = new BindableNumber<float> { MinValue = 0, MaxValue = 360 };
+
         [Resolved]
         private GameHost host { get; set; }
 
@@ -110,12 +112,6 @@ namespace osu.Game.Overlays.Settings.Sections.Input
                             }
                         },
                         new SettingsSlider<float>
-                        {
-                            TransferValueOnCommit = true,
-                            LabelText = "Aspect Ratio",
-                            Current = aspectRatio
-                        },
-                        new SettingsSlider<float>
                         {
                             TransferValueOnCommit = true,
                             LabelText = "X Offset",
@@ -127,6 +123,19 @@ namespace osu.Game.Overlays.Settings.Sections.Input
                             LabelText = "Y Offset",
                             Current = offsetY
                         },
+                        new SettingsSlider<float>
+                        {
+                            TransferValueOnCommit = true,
+                            LabelText = "Rotation",
+                            Current = rotation
+                        },
+                        new RotationPresetButtons(tabletHandler),
+                        new SettingsSlider<float>
+                        {
+                            TransferValueOnCommit = true,
+                            LabelText = "Aspect Ratio",
+                            Current = aspectRatio
+                        },
                         new SettingsCheckbox
                         {
                             LabelText = "Lock aspect ratio",
@@ -153,6 +162,8 @@ namespace osu.Game.Overlays.Settings.Sections.Input
         {
             base.LoadComplete();
 
+            rotation.BindTo(tabletHandler.Rotation);
+
             areaOffset.BindTo(tabletHandler.AreaOffset);
             areaOffset.BindValueChanged(val =>
             {

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -438,6 +438,8 @@ namespace osu.Game.Rulesets.Edit
         /// </summary>
         public abstract bool CursorInPlacementArea { get; }
 
+        public virtual string ConvertSelectionToString() => string.Empty;
+
         #region IPositionSnapProvider
 
         public abstract SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition);

osu.Game/Rulesets/RulesetStore.cs

@@ -173,7 +173,7 @@ namespace osu.Game.Rulesets
         {
             var filename = Path.GetFileNameWithoutExtension(file);
 
-            if (loadedAssemblies.Values.Any(t => t.Namespace == filename))
+            if (loadedAssemblies.Values.Any(t => Path.GetFileNameWithoutExtension(t.Assembly.Location) == filename))
                 return;
 
             try

osu.Game/Rulesets/Scoring/ScoreProcessor.cs

@@ -337,7 +337,7 @@ namespace osu.Game.Rulesets.Scoring
             score.TotalScore = (long)Math.Round(GetStandardisedScore());
             score.Combo = Combo.Value;
             score.MaxCombo = HighestCombo.Value;
-            score.Accuracy = Math.Round(Accuracy.Value, 4);
+            score.Accuracy = Accuracy.Value;
             score.Rank = Rank.Value;
             score.Date = DateTimeOffset.Now;
 

osu.Game/Scoring/ScoreInfo.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Scoring
         public long TotalScore { get; set; }
 
         [JsonProperty("accuracy")]
-        [Column(TypeName = "DECIMAL(1,4)")]
+        [Column(TypeName = "DECIMAL(1,4)")] // TODO: This data type is wrong (should contain more precision). But at the same time, we probably don't need to be storing this in the database.
         public double Accuracy { get; set; }
 
         [JsonIgnore]

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

@@ -10,6 +10,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
+using osu.Framework.Input.Events;
 using osu.Game.Audio;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
@@ -19,6 +20,7 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osuTK;
+using osuTK.Input;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
@@ -70,6 +72,50 @@ namespace osu.Game.Screens.Edit.Compose.Components
             }
         }
 
+        protected override bool OnKeyDown(KeyDownEvent e)
+        {
+            if (e.ControlPressed)
+            {
+                switch (e.Key)
+                {
+                    case Key.Left:
+                        moveSelection(new Vector2(-1, 0));
+                        return true;
+
+                    case Key.Right:
+                        moveSelection(new Vector2(1, 0));
+                        return true;
+
+                    case Key.Up:
+                        moveSelection(new Vector2(0, -1));
+                        return true;
+
+                    case Key.Down:
+                        moveSelection(new Vector2(0, 1));
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Move the current selection spatially by the specified delta, in gamefield coordinates (ie. the same coordinates as the blueprints).
+        /// </summary>
+        /// <param name="delta"></param>
+        private void moveSelection(Vector2 delta)
+        {
+            var firstBlueprint = SelectionHandler.SelectedBlueprints.FirstOrDefault();
+
+            if (firstBlueprint == null)
+                return;
+
+            // convert to game space coordinates
+            delta = firstBlueprint.ToScreenSpace(delta) - firstBlueprint.ToScreenSpace(Vector2.Zero);
+
+            SelectionHandler.HandleMovement(new MoveSelectionEvent(firstBlueprint, firstBlueprint.ScreenSpaceSelectionPoint + delta));
+        }
+
         private void updatePlacementNewCombo()
         {
             if (currentPlacement?.HitObject is IHasComboInformation c)

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

@@ -71,7 +71,13 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
             // Put earlier blueprints towards the end of the list, so they handle input first
             int i = yObj.HitObject.StartTime.CompareTo(xObj.HitObject.StartTime);
-            return i == 0 ? CompareReverseChildID(x, y) : i;
+
+            if (i != 0) return i;
+
+            // Fall back to end time if the start time is equal.
+            i = yObj.HitObject.GetEndTime().CompareTo(xObj.HitObject.GetEndTime());
+
+            return i == 0 ? CompareReverseChildID(y, x) : i;
         }
     }
 }

osu.Game/Screens/Edit/Compose/Components/Timeline/TimelineBlueprintContainer.cs

@@ -2,6 +2,8 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
@@ -121,14 +123,55 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             }
 
             base.Update();
+
+            updateStacking();
+        }
+
+        private void updateStacking()
+        {
+            // because only blueprints of objects which are alive (via pooling) are displayed in the timeline, it's feasible to do this every-update.
+
+            const int stack_offset = 5;
+
+            // after the stack gets this tall, we can presume there is space underneath to draw subsequent blueprints.
+            const int stack_reset_count = 3;
+
+            Stack<HitObject> currentConcurrentObjects = new Stack<HitObject>();
+
+            foreach (var b in SelectionBlueprints.Reverse())
+            {
+                // remove objects from the stack as long as their end time is in the past.
+                while (currentConcurrentObjects.TryPeek(out HitObject hitObject))
+                {
+                    if (Precision.AlmostBigger(hitObject.GetEndTime(), b.HitObject.StartTime, 1))
+                        break;
+
+                    currentConcurrentObjects.Pop();
+                }
+
+                // if the stack gets too high, we should have space below it to display the next batch of objects.
+                // importantly, we only do this if time has incremented, else a stack of hitobjects all at the same time value would start to overlap themselves.
+                if (currentConcurrentObjects.TryPeek(out HitObject h) && !Precision.AlmostEquals(h.StartTime, b.HitObject.StartTime, 1))
+                {
+                    if (currentConcurrentObjects.Count >= stack_reset_count)
+                        currentConcurrentObjects.Clear();
+                }
+
+                b.Y = -(stack_offset * currentConcurrentObjects.Count);
+
+                currentConcurrentObjects.Push(b.HitObject);
+            }
         }
 
         protected override SelectionHandler CreateSelectionHandler() => new TimelineSelectionHandler();
 
-        protected override SelectionBlueprint CreateBlueprintFor(HitObject hitObject) => new TimelineHitObjectBlueprint(hitObject)
+        protected override SelectionBlueprint CreateBlueprintFor(HitObject hitObject)
+        {
+            return new TimelineHitObjectBlueprint(hitObject)
             {
                 OnDragHandled = handleScrollViaDrag
             };
+        }
 
         protected override DragBox CreateDragBox(Action<RectangleF> performSelect) => new TimelineDragBox(performSelect);
 
@@ -203,7 +246,13 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                 Box.X = Math.Min(rescaledStart, rescaledEnd);
                 Box.Width = Math.Abs(rescaledStart - rescaledEnd);
 
-                PerformSelection?.Invoke(Box.ScreenSpaceDrawQuad.AABBFloat);
+                var boxScreenRect = Box.ScreenSpaceDrawQuad.AABBFloat;
+
+                // we don't care about where the hitobjects are vertically. in cases like stacking display, they may be outside the box without this adjustment.
+                boxScreenRect.Y -= boxScreenRect.Height;
+                boxScreenRect.Height *= 2;
+
+                PerformSelection?.Invoke(boxScreenRect);
             }
 
             public override void Hide()

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

@@ -2,11 +2,16 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Diagnostics;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Platform;
 using osu.Game.Beatmaps;
+using osu.Game.Extensions;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
@@ -14,11 +19,17 @@ using osu.Game.Skinning;
 
 namespace osu.Game.Screens.Edit.Compose
 {
-    public class ComposeScreen : EditorScreenWithTimeline
+    public class ComposeScreen : EditorScreenWithTimeline, IKeyBindingHandler<PlatformAction>
     {
         [Resolved]
         private IBindable<WorkingBeatmap> beatmap { get; set; }
 
+        [Resolved]
+        private GameHost host { get; set; }
+
+        [Resolved]
+        private EditorClock clock { get; set; }
+
         private HitObjectComposer composer;
 
         public ComposeScreen()
@@ -72,5 +83,34 @@ namespace osu.Game.Screens.Edit.Compose
             // this is intentionally done in two stages to ensure things are in a loaded state before exposing the ruleset to skin sources.
             return beatmapSkinProvider.WithChild(rulesetSkinProvider.WithChild(content));
         }
+
+        #region Input Handling
+
+        public bool OnPressed(PlatformAction action)
+        {
+            if (action.ActionType == PlatformActionType.Copy)
+                host.GetClipboard().SetText(formatSelectionAsString());
+
+            return false;
+        }
+
+        public void OnReleased(PlatformAction action)
+        {
+        }
+
+        private string formatSelectionAsString()
+        {
+            if (composer == null)
+                return string.Empty;
+
+            double displayTime = EditorBeatmap.SelectedHitObjects.OrderBy(h => h.StartTime).FirstOrDefault()?.StartTime ?? clock.CurrentTime;
+            string selectionAsString = composer.ConvertSelectionToString();
+
+            return !string.IsNullOrEmpty(selectionAsString)
+                ? $"{displayTime.ToEditorFormattedString()} ({selectionAsString}) - "
+                : $"{displayTime.ToEditorFormattedString()} - ";
+        }
+
+        #endregion
     }
 }

osu.Game/Screens/Edit/Editor.cs

@@ -16,7 +16,6 @@ using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
 using osu.Framework.Logging;
-using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
@@ -103,7 +102,7 @@ namespace osu.Game.Screens.Edit
         private MusicController music { get; set; }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, GameHost host, OsuConfigManager config)
+        private void load(OsuColour colours, OsuConfigManager config)
         {
             var loadableBeatmap = Beatmap.Value;
 

osu.Game/Screens/Edit/Timing/DifficultySection.cs

@@ -28,7 +28,16 @@ namespace osu.Game.Screens.Edit.Timing
         {
             if (point.NewValue != null)
             {
-                multiplierSlider.Current = point.NewValue.SpeedMultiplierBindable;
+                var selectedPointBindable = point.NewValue.SpeedMultiplierBindable;
+
+                // there may be legacy control points, which contain infinite precision for compatibility reasons (see LegacyDifficultyControlPoint).
+                // generally that level of precision could only be set by externally editing the .osu file, so at the point
+                // a user is looking to update this within the editor it should be safe to obliterate this additional precision.
+                double expectedPrecision = new DifficultyControlPoint().SpeedMultiplierBindable.Precision;
+                if (selectedPointBindable.Precision < expectedPrecision)
+                    selectedPointBindable.Precision = expectedPrecision;
+
+                multiplierSlider.Current = selectedPointBindable;
                 multiplierSlider.Current.BindValueChanged(_ => ChangeHandler?.SaveState());
             }
         }

osu.Game/Screens/OnlinePlay/Lounge/LoungeSubScreen.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Diagnostics;
 using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
@@ -170,7 +169,9 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
 
         private void joinRequested(Room room)
         {
-            Debug.Assert(joiningRoomOperation == null);
+            if (joiningRoomOperation != null)
+                return;
+
             joiningRoomOperation = ongoingOperationTracker?.BeginOperation();
 
             RoomManager?.JoinRoom(room, r =>

osu.Game/Screens/Play/HUD/LegacyComboCounter.cs

@@ -6,7 +6,6 @@ using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Graphics.Sprites;
 using osu.Game.Skinning;
 using osuTK;
 
@@ -84,16 +83,16 @@ namespace osu.Game.Screens.Play.HUD
         {
             InternalChildren = new[]
             {
-                popOutCount = createSpriteText().With(s =>
+                popOutCount = new LegacySpriteText(skin, LegacyFont.Combo)
                 {
-                    s.Alpha = 0;
+                    Alpha = 0,
-                    s.Margin = new MarginPadding(0.05f);
+                    Margin = new MarginPadding(0.05f),
-                    s.Blending = BlendingParameters.Additive;
+                    Blending = BlendingParameters.Additive,
-                }),
+                },
-                displayedCountSpriteText = createSpriteText().With(s =>
+                displayedCountSpriteText = new LegacySpriteText(skin, LegacyFont.Combo)
                 {
-                    s.Alpha = 0;
+                    Alpha = 0,
-                })
+                },
             };
 
             Current.ValueChanged += combo => updateCount(combo.NewValue == 0);
@@ -247,7 +246,5 @@ namespace osu.Game.Screens.Play.HUD
             double difference = currentValue > newValue ? currentValue - newValue : newValue - currentValue;
             return difference * rolling_duration;
         }
-
-        private OsuSpriteText createSpriteText() => (OsuSpriteText)skin.GetDrawableComponent(new HUDSkinComponent(HUDSkinComponents.ComboText));
     }
 }

osu.Game/Screens/Play/PlayerLoader.cs

@@ -309,10 +309,8 @@ namespace osu.Game.Screens.Play
             if (!this.IsCurrentScreen())
                 return;
 
-            var restartCount = player?.RestartCount + 1 ?? 0;
-
             player = createPlayer();
-            player.RestartCount = restartCount;
+            player.RestartCount = restartCount++;
             player.RestartRequested = restartRequested;
 
             LoadTask = LoadComponentAsync(player, _ => MetadataInfo.Loading = false);
@@ -428,6 +426,8 @@ namespace osu.Game.Screens.Play
 
         private Bindable<bool> muteWarningShownOnce;
 
+        private int restartCount;
+
         private void showMuteWarningIfNeeded()
         {
             if (!muteWarningShownOnce.Value)

osu.Game/Skinning/HUDSkinComponents.cs

@@ -9,7 +9,5 @@ namespace osu.Game.Skinning
         ScoreCounter,
         AccuracyCounter,
         HealthDisplay,
-        ScoreText,
-        ComboText,
     }
 }

osu.Game/Skinning/LegacyAccuracyCounter.cs

@@ -29,9 +29,11 @@ namespace osu.Game.Skinning
         [Resolved(canBeNull: true)]
         private HUDOverlay hud { get; set; }
 
-        protected sealed override OsuSpriteText CreateSpriteText()
+        protected sealed override OsuSpriteText CreateSpriteText() => new LegacySpriteText(skin, LegacyFont.Score)
-            => (OsuSpriteText)skin?.GetDrawableComponent(new HUDSkinComponent(HUDSkinComponents.ScoreText))
+        {
-                                  ?.With(s => s.Anchor = s.Origin = Anchor.TopRight);
+            Anchor = Anchor.TopRight,
+            Origin = Anchor.TopRight,
+        };
 
         protected override void Update()
         {

osu.Game/Skinning/LegacyFont.cs

@@ -0,0 +1,15 @@
+// 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.
+
+namespace osu.Game.Skinning
+{
+    /// <summary>
+    /// The type of legacy font to use for <see cref="LegacySpriteText"/>s.
+    /// </summary>
+    public enum LegacyFont
+    {
+        Score,
+        Combo,
+        HitCircle,
+    }
+}

osu.Game/Skinning/LegacyRollingCounter.cs

@@ -4,7 +4,6 @@
 using System;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
-using osuTK;
 
 namespace osu.Game.Skinning
 {
@@ -14,9 +13,7 @@ namespace osu.Game.Skinning
     public class LegacyRollingCounter : RollingCounter<int>
     {
         private readonly ISkin skin;
-
+        private readonly LegacyFont font;
-        private readonly string fontName;
-        private readonly float fontOverlap;
 
         protected override bool IsRollingProportional => true;
 
@@ -24,17 +21,11 @@ namespace osu.Game.Skinning
         /// Creates a new <see cref="LegacyRollingCounter"/>.
         /// </summary>
         /// <param name="skin">The <see cref="ISkin"/> from which to get counter number sprites.</param>
-        /// <param name="fontName">The name of the legacy font to use.</param>
+        /// <param name="font">The legacy font to use for the counter.</param>
-        /// <param name="fontOverlap">
+        public LegacyRollingCounter(ISkin skin, LegacyFont font)
-        /// The numeric overlap of number sprites to use.
-        /// A positive number will bring the number sprites closer together, while a negative number
-        /// will split them apart more.
-        /// </param>
-        public LegacyRollingCounter(ISkin skin, string fontName, float fontOverlap)
         {
             this.skin = skin;
-            this.fontName = fontName;
+            this.font = font;
-            this.fontOverlap = fontOverlap;
         }
 
         protected override double GetProportionalDuration(int currentValue, int newValue)
@@ -42,10 +33,6 @@ namespace osu.Game.Skinning
             return Math.Abs(newValue - currentValue) * 75.0;
         }
 
-        protected sealed override OsuSpriteText CreateSpriteText() =>
+        protected sealed override OsuSpriteText CreateSpriteText() => new LegacySpriteText(skin, font);
-            new LegacySpriteText(skin, fontName)
-            {
-                Spacing = new Vector2(-fontOverlap, 0f)
-            };
     }
 }

osu.Game/Skinning/LegacyScoreCounter.cs

@@ -33,8 +33,10 @@ namespace osu.Game.Skinning
             Margin = new MarginPadding(10);
         }
 
-        protected sealed override OsuSpriteText CreateSpriteText()
+        protected sealed override OsuSpriteText CreateSpriteText() => new LegacySpriteText(skin, LegacyFont.Score)
-            => (OsuSpriteText)skin.GetDrawableComponent(new HUDSkinComponent(HUDSkinComponents.ScoreText))
+        {
-                                  .With(s => s.Anchor = s.Origin = Anchor.TopRight);
+            Anchor = Anchor.TopRight,
+            Origin = Anchor.TopRight,
+        };
     }
 }

osu.Game/Skinning/LegacySkin.cs

@@ -18,7 +18,6 @@ using osu.Game.Beatmaps.Formats;
 using osu.Game.IO;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play.HUD;
-using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Game.Skinning
@@ -320,19 +319,13 @@ namespace osu.Game.Skinning
             return null;
         }
 
-        private string scorePrefix => GetConfig<LegacySkinConfiguration.LegacySetting, string>(LegacySkinConfiguration.LegacySetting.ScorePrefix)?.Value ?? "score";
-
-        private string comboPrefix => GetConfig<LegacySkinConfiguration.LegacySetting, string>(LegacySkinConfiguration.LegacySetting.ComboPrefix)?.Value ?? "score";
-
-        private bool hasScoreFont => this.HasFont(scorePrefix);
-
         public override Drawable GetDrawableComponent(ISkinComponent component)
         {
             switch (component)
             {
                 case HUDSkinComponent hudComponent:
                 {
-                    if (!hasScoreFont)
+                    if (!this.HasFont(LegacyFont.Score))
                         return null;
 
                     switch (hudComponent.Component)
@@ -348,18 +341,6 @@ namespace osu.Game.Skinning
 
                         case HUDSkinComponents.HealthDisplay:
                             return new LegacyHealthDisplay(this);
-
-                        case HUDSkinComponents.ComboText:
-                            return new LegacySpriteText(this, comboPrefix)
-                            {
-                                Spacing = new Vector2(-(GetConfig<LegacySkinConfiguration.LegacySetting, int>(LegacySkinConfiguration.LegacySetting.ComboOverlap)?.Value ?? -2), 0)
-                            };
-
-                        case HUDSkinComponents.ScoreText:
-                            return new LegacySpriteText(this, scorePrefix)
-                            {
-                                Spacing = new Vector2(-(GetConfig<LegacySkinConfiguration.LegacySetting, int>(LegacySkinConfiguration.LegacySetting.ScoreOverlap)?.Value ?? -2), 0)
-                            };
                     }
 
                     return null;

osu.Game/Skinning/LegacySkinConfiguration.cs

@@ -19,6 +19,8 @@ namespace osu.Game.Skinning
             ComboOverlap,
             ScorePrefix,
             ScoreOverlap,
+            HitCirclePrefix,
+            HitCircleOverlap,
             AnimationFramerate,
             LayeredHitSounds
         }

osu.Game/Skinning/LegacySkinExtensions.cs

@@ -1,6 +1,7 @@
 // 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.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
@@ -63,8 +64,51 @@ namespace osu.Game.Skinning
             }
         }
 
-        public static bool HasFont(this ISkin source, string fontPrefix)
+        public static bool HasFont(this ISkin source, LegacyFont font)
-            => source.GetTexture($"{fontPrefix}-0") != null;
+        {
+            return source.GetTexture($"{source.GetFontPrefix(font)}-0") != null;
+        }
+
+        public static string GetFontPrefix(this ISkin source, LegacyFont font)
+        {
+            switch (font)
+            {
+                case LegacyFont.Score:
+                    return source.GetConfig<LegacySetting, string>(LegacySetting.ScorePrefix)?.Value ?? "score";
+
+                case LegacyFont.Combo:
+                    return source.GetConfig<LegacySetting, string>(LegacySetting.ComboPrefix)?.Value ?? "score";
+
+                case LegacyFont.HitCircle:
+                    return source.GetConfig<LegacySetting, string>(LegacySetting.HitCirclePrefix)?.Value ?? "default";
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(font));
+            }
+        }
+
+        /// <summary>
+        /// Returns the numeric overlap of number sprites to use.
+        /// A positive number will bring the number sprites closer together, while a negative number
+        /// will split them apart more.
+        /// </summary>
+        public static float GetFontOverlap(this ISkin source, LegacyFont font)
+        {
+            switch (font)
+            {
+                case LegacyFont.Score:
+                    return source.GetConfig<LegacySetting, float>(LegacySetting.ScoreOverlap)?.Value ?? 0f;
+
+                case LegacyFont.Combo:
+                    return source.GetConfig<LegacySetting, float>(LegacySetting.ComboOverlap)?.Value ?? 0f;
+
+                case LegacyFont.HitCircle:
+                    return source.GetConfig<LegacySetting, float>(LegacySetting.HitCircleOverlap)?.Value ?? -2f;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(font));
+            }
+        }
 
         public class SkinnableTextureAnimation : TextureAnimation
         {

osu.Game/Skinning/LegacySpriteText.cs

@@ -5,6 +5,7 @@ using System.Threading.Tasks;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Text;
 using osu.Game.Graphics.Sprites;
+using osuTK;
 
 namespace osu.Game.Skinning
 {
@@ -16,12 +17,14 @@ namespace osu.Game.Skinning
 
         protected override char[] FixedWidthExcludeCharacters => new[] { ',', '.', '%', 'x' };
 
-        public LegacySpriteText(ISkin skin, string font = "score")
+        public LegacySpriteText(ISkin skin, LegacyFont font)
         {
             Shadow = false;
             UseFullGlyphHeight = false;
 
-            Font = new FontUsage(font, 1, fixedWidth: true);
+            Font = new FontUsage(skin.GetFontPrefix(font), 1, fixedWidth: true);
+            Spacing = new Vector2(-skin.GetFontOverlap(font), 0);
+
             glyphStore = new LegacyGlyphStore(skin);
         }
 

osu.Game/Users/UserStatistics.cs

@@ -42,10 +42,10 @@ namespace osu.Game.Users
         public long RankedScore;
 
         [JsonProperty(@"hit_accuracy")]
-        public decimal Accuracy;
+        public double Accuracy;
 
         [JsonIgnore]
-        public string DisplayAccuracy => Accuracy.FormatAccuracy();
+        public string DisplayAccuracy => (Accuracy / 100).FormatAccuracy();
 
         [JsonProperty(@"play_count")]
         public int PlayCount;

osu.Game/Utils/FormatUtils.cs

@@ -1,6 +1,8 @@
 // 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.Globalization;
 using Humanizer;
 
 namespace osu.Game.Utils
@@ -10,16 +12,19 @@ namespace osu.Game.Utils
         /// <summary>
         /// Turns the provided accuracy into a percentage with 2 decimal places.
         /// </summary>
-        /// <param name="accuracy">The accuracy to be formatted</param>
+        /// <param name="accuracy">The accuracy to be formatted.</param>
+        /// <param name="formatProvider">An optional format provider.</param>
         /// <returns>formatted accuracy in percentage</returns>
-        public static string FormatAccuracy(this double accuracy) => $"{accuracy:0.00%}";
+        public static string FormatAccuracy(this double accuracy, IFormatProvider formatProvider = null)
+        {
+            // for the sake of display purposes, we don't want to show a user a "rounded up" percentage to the next whole number.
+            // ie. a score which gets 89.99999% shouldn't ever show as 90%.
+            // the reasoning for this is that cutoffs for grade increases are at whole numbers and displaying the required
+            // percentile with a non-matching grade is confusing.
+            accuracy = Math.Floor(accuracy * 10000) / 10000;
 
-        /// <summary>
+            return accuracy.ToString("0.00%", formatProvider ?? CultureInfo.CurrentCulture);
-        /// Turns the provided accuracy into a percentage with 2 decimal places.
+        }
-        /// </summary>
-        /// <param name="accuracy">The accuracy to be formatted</param>
-        /// <returns>formatted accuracy in percentage</returns>
-        public static string FormatAccuracy(this decimal accuracy) => $"{accuracy:0.00}%";
 
         /// <summary>
         /// Formats the supplied rank/leaderboard position in a consistent, simplified way.

osu.Game/osu.Game.csproj

@@ -18,20 +18,20 @@
     </None>
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="DiffPlex" Version="1.6.3" />
+    <PackageReference Include="DiffPlex" Version="1.7.0" />
     <PackageReference Include="Humanizer" Version="2.8.26" />
     <PackageReference Include="MessagePack" Version="2.2.85" />
-    <PackageReference Include="Microsoft.AspNetCore.SignalR.Client" Version="5.0.2" />
+    <PackageReference Include="Microsoft.AspNetCore.SignalR.Client" Version="5.0.4" />
-    <PackageReference Include="Microsoft.AspNetCore.SignalR.Protocols.MessagePack" Version="5.0.3" />
+    <PackageReference Include="Microsoft.AspNetCore.SignalR.Protocols.MessagePack" Version="5.0.4" />
-    <PackageReference Include="Microsoft.AspNetCore.SignalR.Protocols.NewtonsoftJson" Version="5.0.2" />
+    <PackageReference Include="Microsoft.AspNetCore.SignalR.Protocols.NewtonsoftJson" Version="5.0.4" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="5.0.0" />
     <PackageReference Include="Microsoft.NETCore.Targets" Version="3.1.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="ppy.osu.Framework" Version="2021.323.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2021.330.0" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2021.211.1" />
-    <PackageReference Include="Sentry" Version="3.0.7" />
+    <PackageReference Include="Sentry" Version="3.2.0" />
     <PackageReference Include="SharpCompress" Version="0.28.1" />
     <PackageReference Include="NUnit" Version="3.13.1" />
     <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />

osu.iOS.props

@@ -70,7 +70,7 @@
     <Reference Include="System.Net.Http" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2021.323.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2021.330.0" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2021.211.1" />
   </ItemGroup>
   <!-- See https://github.com/dotnet/runtime/issues/35988 (can be removed after Xamarin uses net5.0 / net6.0) -->
@@ -93,7 +93,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-    <PackageReference Include="ppy.osu.Framework" Version="2021.323.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2021.330.0" />
     <PackageReference Include="SharpCompress" Version="0.28.1" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />