Merge branch 'master' into fix-skin-layout-editor-crash

.editorconfig

@@ -113,7 +113,7 @@ dotnet_style_qualification_for_event = false:warning
 dotnet_style_predefined_type_for_locals_parameters_members = true:warning
 dotnet_style_predefined_type_for_member_access = true:warning
 csharp_style_var_when_type_is_apparent = true:none
-csharp_style_var_for_built_in_types = true:none
+csharp_style_var_for_built_in_types = false:warning
 csharp_style_var_elsewhere = true:silent
 
 #Style - modifiers

.github/workflows/ci.yml

@@ -50,6 +50,48 @@ jobs:
           name: osu-test-results-${{matrix.os.prettyname}}-${{matrix.threadingMode}}
           path: ${{github.workspace}}/TestResults/TestResults-${{matrix.os.prettyname}}-${{matrix.threadingMode}}.trx
 
+  build-only-android:
+    name: Build only (Android)
+    runs-on: windows-latest
+    timeout-minutes: 60
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Install .NET 5.0.x
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: "5.0.x"
+
+      - name: Setup MSBuild
+        uses: microsoft/setup-msbuild@v1
+
+      - name: Build
+        run: msbuild osu.Android.slnf /restore /p:Configuration=Debug
+
+  build-only-ios:
+    # While this workflow technically *can* run, it fails as iOS builds are blocked by multiple issues.
+    # See https://github.com/ppy/osu-framework/issues/4677 for the details.
+    # The job can be unblocked once those issues are resolved and game deployments can happen again.
+    if: false
+    name: Build only (iOS)
+    runs-on: macos-latest
+    timeout-minutes: 60
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Install .NET 5.0.x
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: "5.0.x"
+
+      # Contrary to seemingly any other msbuild, msbuild running on macOS/Mono
+      # cannot accept .sln(f) files as arguments.
+      # Build just the main game for now.
+      - name: Build
+        run: msbuild osu.iOS/osu.iOS.csproj /restore /p:Configuration=Debug
+
   inspect-code:
     name: Code Quality
     runs-on: ubuntu-latest

osu.Android.props

@@ -51,8 +51,8 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1015.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2021.1026.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.1014.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2021.1026.0" />
   </ItemGroup>
   <ItemGroup Label="Transitive Dependencies">
     <!-- Realm needs to be directly referenced in all Xamarin projects, as it will not pull in its transitive dependencies otherwise. -->

osu.Desktop/OsuGameDesktop.cs

@@ -156,7 +156,7 @@ namespace osu.Desktop
         {
             lock (importableFiles)
             {
-                var firstExtension = Path.GetExtension(filePaths.First());
+                string firstExtension = Path.GetExtension(filePaths.First());
 
                 if (filePaths.Any(f => Path.GetExtension(f) != firstExtension)) return;
 
@@ -177,7 +177,7 @@ namespace osu.Desktop
             {
                 Logger.Log($"Handling batch import of {importableFiles.Count} files");
 
-                var paths = importableFiles.ToArray();
+                string[] paths = importableFiles.ToArray();
                 importableFiles.Clear();
 
                 Task.Factory.StartNew(() => Import(paths), TaskCreationOptions.LongRunning);

osu.Desktop/Program.cs

@@ -22,17 +22,17 @@ namespace osu.Desktop
         public static int Main(string[] args)
         {
             // Back up the cwd before DesktopGameHost changes it
-            var cwd = Environment.CurrentDirectory;
+            string cwd = Environment.CurrentDirectory;
 
             string gameName = base_game_name;
             bool tournamentClient = false;
 
-            foreach (var arg in args)
+            foreach (string arg in args)
             {
-                var split = arg.Split('=');
+                string[] split = arg.Split('=');
 
-                var key = split[0];
+                string key = split[0];
-                var val = split.Length > 1 ? split[1] : string.Empty;
+                string val = split.Length > 1 ? split[1] : string.Empty;
 
                 switch (key)
                 {
@@ -62,7 +62,7 @@ namespace osu.Desktop
                     {
                         var importer = new ArchiveImportIPCChannel(host);
 
-                        foreach (var file in args)
+                        foreach (string file in args)
                         {
                             Console.WriteLine(@"Importing {0}", file);
                             if (!importer.ImportAsync(Path.GetFullPath(file, cwd)).Wait(3000))

osu.Game.Rulesets.Catch.Tests/Editor/TestSceneCatchDistanceSnapGrid.cs

@@ -0,0 +1,91 @@
+// 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.Input.Events;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Catch.Edit;
+using osu.Game.Rulesets.Catch.Edit.Blueprints.Components;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Tests.Editor
+{
+    public class TestSceneCatchDistanceSnapGrid : OsuManualInputManagerTestScene
+    {
+        private readonly ManualClock manualClock = new ManualClock();
+
+        [Cached(typeof(Playfield))]
+        private readonly CatchPlayfield playfield;
+
+        private ScrollingHitObjectContainer hitObjectContainer => playfield.HitObjectContainer;
+
+        private readonly CatchDistanceSnapGrid distanceGrid;
+
+        private readonly FruitOutline fruitOutline;
+
+        private readonly Fruit fruit = new Fruit();
+
+        public TestSceneCatchDistanceSnapGrid()
+        {
+            Child = new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                RelativeSizeAxes = Axes.Y,
+                Width = 500,
+
+                Children = new Drawable[]
+                {
+                    new ScrollingTestContainer(ScrollingDirection.Down)
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Child = playfield = new CatchPlayfield(new BeatmapDifficulty())
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Clock = new FramedClock(manualClock)
+                        }
+                    },
+                    distanceGrid = new CatchDistanceSnapGrid(new double[] { 0, -1, 1 }),
+                    fruitOutline = new FruitOutline()
+                },
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            distanceGrid.StartTime = 100;
+            distanceGrid.StartX = 250;
+
+            Vector2 screenSpacePosition = InputManager.CurrentState.Mouse.Position;
+
+            var result = distanceGrid.GetSnappedPosition(screenSpacePosition);
+
+            if (result != null)
+            {
+                fruit.OriginalX = hitObjectContainer.ToLocalSpace(result.ScreenSpacePosition).X;
+
+                if (result.Time != null)
+                    fruit.StartTime = result.Time.Value;
+            }
+
+            fruitOutline.Position = CatchHitObjectUtils.GetStartPosition(hitObjectContainer, fruit);
+            fruitOutline.UpdateFrom(fruit);
+        }
+
+        protected override bool OnScroll(ScrollEvent e)
+        {
+            manualClock.CurrentTime -= e.ScrollDelta.Y * 50;
+            return true;
+        }
+    }
+}

osu.Game.Rulesets.Catch.Tests/Editor/TestSceneJuiceStreamSelectionBlueprint.cs

@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Editor
 
             AddAssert("correct outline count", () =>
             {
-                var expected = hitObject.NestedHitObjects.Count(h => !(h is TinyDroplet));
+                int expected = hitObject.NestedHitObjects.Count(h => !(h is TinyDroplet));
                 return this.ChildrenOfType<FruitOutline>().Count() == expected;
             });
             AddAssert("correct vertex piece count", () =>

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

@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         [Test]
         public void TestCatcherCatchWidth()
         {
-            var halfWidth = Catcher.CalculateCatchWidth(new BeatmapDifficulty { CircleSize = 0 }) / 2;
+            float halfWidth = Catcher.CalculateCatchWidth(new BeatmapDifficulty { CircleSize = 0 }) / 2;
             AddStep("catch fruit", () =>
             {
                 attemptCatch(new Fruit { X = -halfWidth + 1 });
@@ -237,7 +237,7 @@ namespace osu.Game.Rulesets.Catch.Tests
 
         private void attemptCatch(Func<CatchHitObject> hitObject, int count)
         {
-            for (var i = 0; i < count; i++)
+            for (int i = 0; i < count; i++)
                 attemptCatch(hitObject(), out _, out _);
         }
 

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

@@ -118,7 +118,7 @@ namespace osu.Game.Rulesets.Catch.Tests
 
         private void spawnJuiceStream(bool hit = false)
         {
-            var xCoords = getXCoords(hit);
+            float xCoords = getXCoords(hit);
 
             var juice = new JuiceStream
             {

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

@@ -233,7 +233,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 int thisDirection = nextObject.EffectiveX > currentObject.EffectiveX ? 1 : -1;
                 double timeToNext = nextObject.StartTime - currentObject.StartTime - 1000f / 60f / 4; // 1/4th of a frame of grace time, taken from osu-stable
                 double distanceToNext = Math.Abs(nextObject.EffectiveX - currentObject.EffectiveX) - (lastDirection == thisDirection ? lastExcess : halfCatcherWidth);
-                float distanceToHyper = (float)(timeToNext * Catcher.BASE_SPEED - distanceToNext);
+                float distanceToHyper = (float)(timeToNext * Catcher.BASE_DASH_SPEED - distanceToNext);
 
                 if (distanceToHyper < 0)
                 {

osu.Game.Rulesets.Catch/Difficulty/Preprocessing/CatchDifficultyHitObject.cs

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
             : base(hitObject, lastObject, clockRate)
         {
             // We will scale everything by this factor, so we can assume a uniform CircleSize among beatmaps.
-            var scalingFactor = normalized_hitobject_radius / halfCatcherWidth;
+            float scalingFactor = normalized_hitobject_radius / halfCatcherWidth;
 
             NormalizedPosition = BaseObject.EffectiveX * scalingFactor;
             LastNormalizedPosition = LastObject.EffectiveX * scalingFactor;

osu.Game.Rulesets.Catch/Edit/CatchDistanceSnapGrid.cs

@@ -0,0 +1,141 @@
+// 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 JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Lines;
+using osu.Framework.Graphics.Primitives;
+using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;
+
+namespace osu.Game.Rulesets.Catch.Edit
+{
+    /// <summary>
+    /// The guide lines used in the osu!catch editor to compose patterns that can be caught with constant speed.
+    /// Currently, only forward placement (an object is snapped based on the previous object, not the opposite) is supported.
+    /// </summary>
+    public class CatchDistanceSnapGrid : CompositeDrawable
+    {
+        public double StartTime { get; set; }
+
+        public float StartX { get; set; }
+
+        private const double max_vertical_line_length_in_time = CatchPlayfield.WIDTH / Catcher.BASE_WALK_SPEED;
+
+        private readonly double[] velocities;
+
+        private readonly List<Path> verticalPaths = new List<Path>();
+
+        private readonly List<Vector2[]> verticalLineVertices = new List<Vector2[]>();
+
+        [Resolved]
+        private Playfield playfield { get; set; }
+
+        private ScrollingHitObjectContainer hitObjectContainer => (ScrollingHitObjectContainer)playfield.HitObjectContainer;
+
+        public CatchDistanceSnapGrid(double[] velocities)
+        {
+            RelativeSizeAxes = Axes.Both;
+            Anchor = Anchor.BottomLeft;
+
+            this.velocities = velocities;
+
+            for (int i = 0; i < velocities.Length; i++)
+            {
+                verticalPaths.Add(new SmoothPath
+                {
+                    PathRadius = 2,
+                    Alpha = 0.5f,
+                });
+
+                verticalLineVertices.Add(new[] { Vector2.Zero, Vector2.Zero });
+            }
+
+            AddRangeInternal(verticalPaths);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            double currentTime = hitObjectContainer.Time.Current;
+
+            for (int i = 0; i < velocities.Length; i++)
+            {
+                double velocity = velocities[i];
+
+                // The line ends at the top of the playfield.
+                double endTime = hitObjectContainer.TimeAtPosition(-hitObjectContainer.DrawHeight, currentTime);
+
+                // Non-vertical lines are cut at the sides of the playfield.
+                // Vertical lines are cut at some reasonable length.
+                if (velocity > 0)
+                    endTime = Math.Min(endTime, StartTime + (CatchPlayfield.WIDTH - StartX) / velocity);
+                else if (velocity < 0)
+                    endTime = Math.Min(endTime, StartTime + StartX / -velocity);
+                else
+                    endTime = Math.Min(endTime, StartTime + max_vertical_line_length_in_time);
+
+                Vector2[] lineVertices = verticalLineVertices[i];
+                lineVertices[0] = calculatePosition(velocity, StartTime);
+                lineVertices[1] = calculatePosition(velocity, endTime);
+
+                var verticalPath = verticalPaths[i];
+                verticalPath.Vertices = verticalLineVertices[i];
+                verticalPath.OriginPosition = verticalPath.PositionInBoundingBox(Vector2.Zero);
+            }
+
+            Vector2 calculatePosition(double velocity, double time)
+            {
+                // Don't draw inverted lines.
+                time = Math.Max(time, StartTime);
+
+                float x = StartX + (float)((time - StartTime) * velocity);
+                float y = hitObjectContainer.PositionAtTime(time, currentTime);
+                return new Vector2(x, y);
+            }
+        }
+
+        [CanBeNull]
+        public SnapResult GetSnappedPosition(Vector2 screenSpacePosition)
+        {
+            double time = hitObjectContainer.TimeAtScreenSpacePosition(screenSpacePosition);
+
+            // If the cursor is below the distance snap grid, snap to the origin.
+            // Not returning `null` to retain the continuous snapping behavior when the cursor is slightly below the origin.
+            // This behavior is not currently visible in the editor because editor chooses the snap start time based on the mouse position.
+            if (time <= StartTime)
+            {
+                float y = hitObjectContainer.PositionAtTime(StartTime);
+                Vector2 originPosition = hitObjectContainer.ToScreenSpace(new Vector2(StartX, y));
+                return new SnapResult(originPosition, StartTime);
+            }
+
+            return enumerateSnappingCandidates(time)
+                   .OrderBy(pos => Vector2.DistanceSquared(screenSpacePosition, pos.ScreenSpacePosition))
+                   .FirstOrDefault();
+        }
+
+        private IEnumerable<SnapResult> enumerateSnappingCandidates(double time)
+        {
+            float y = hitObjectContainer.PositionAtTime(time);
+
+            foreach (double velocity in velocities)
+            {
+                float x = (float)(StartX + (time - StartTime) * velocity);
+                Vector2 screenSpacePosition = hitObjectContainer.ToScreenSpace(new Vector2(x, y + hitObjectContainer.DrawHeight));
+                yield return new SnapResult(screenSpacePosition, time);
+            }
+        }
+
+        protected override bool ComputeIsMaskedAway(RectangleF maskingBounds) => false;
+    }
+}

osu.Game.Rulesets.Catch/Edit/CatchHitObjectComposer.cs

@@ -2,14 +2,23 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 
@@ -17,6 +26,14 @@ namespace osu.Game.Rulesets.Catch.Edit
 {
     public class CatchHitObjectComposer : HitObjectComposer<CatchHitObject>
     {
+        private const float distance_snap_radius = 50;
+
+        private CatchDistanceSnapGrid distanceSnapGrid;
+
+        private readonly Bindable<TernaryState> distanceSnapToggle = new Bindable<TernaryState>();
+
+        private InputManager inputManager;
+
         public CatchHitObjectComposer(CatchRuleset ruleset)
             : base(ruleset)
         {
@@ -30,6 +47,27 @@ namespace osu.Game.Rulesets.Catch.Edit
                 RelativeSizeAxes = Axes.Both,
                 PlayfieldBorderStyle = { Value = PlayfieldBorderStyle.Corners }
             });
+
+            LayerBelowRuleset.Add(distanceSnapGrid = new CatchDistanceSnapGrid(new[]
+            {
+                0.0,
+                Catcher.BASE_DASH_SPEED, -Catcher.BASE_DASH_SPEED,
+                Catcher.BASE_WALK_SPEED, -Catcher.BASE_WALK_SPEED,
+            }));
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            inputManager = GetContainingInputManager();
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            updateDistanceSnapGrid();
         }
 
         protected override DrawableRuleset<CatchHitObject> CreateDrawableRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods = null) =>
@@ -42,14 +80,95 @@ namespace osu.Game.Rulesets.Catch.Edit
             new BananaShowerCompositionTool()
         };
 
+        protected override IEnumerable<TernaryButton> CreateTernaryButtons() => base.CreateTernaryButtons().Concat(new[]
+        {
+            new TernaryButton(distanceSnapToggle, "Distance Snap", () => new SpriteIcon { Icon = FontAwesome.Solid.Ruler })
+        });
+
         public override SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition)
         {
             var result = base.SnapScreenSpacePositionToValidTime(screenSpacePosition);
-            // TODO: implement position snap
             result.ScreenSpacePosition.X = screenSpacePosition.X;
+
+            if (distanceSnapGrid.IsPresent && distanceSnapGrid.GetSnappedPosition(result.ScreenSpacePosition) is SnapResult snapResult &&
+                Vector2.Distance(snapResult.ScreenSpacePosition, result.ScreenSpacePosition) < distance_snap_radius)
+            {
+                result = snapResult;
+            }
+
             return result;
         }
 
         protected override ComposeBlueprintContainer CreateBlueprintContainer() => new CatchBlueprintContainer(this);
+
+        [CanBeNull]
+        private PalpableCatchHitObject getLastSnappableHitObject(double time)
+        {
+            var hitObject = EditorBeatmap.HitObjects.OfType<CatchHitObject>().LastOrDefault(h => h.GetEndTime() < time && !(h is BananaShower));
+
+            switch (hitObject)
+            {
+                case Fruit fruit:
+                    return fruit;
+
+                case JuiceStream juiceStream:
+                    return juiceStream.NestedHitObjects.OfType<PalpableCatchHitObject>().LastOrDefault(h => !(h is TinyDroplet));
+
+                default:
+                    return null;
+            }
+        }
+
+        [CanBeNull]
+        private PalpableCatchHitObject getDistanceSnapGridSourceHitObject()
+        {
+            switch (BlueprintContainer.CurrentTool)
+            {
+                case SelectTool _:
+                    if (EditorBeatmap.SelectedHitObjects.Count == 0)
+                        return null;
+
+                    double minTime = EditorBeatmap.SelectedHitObjects.Min(hitObject => hitObject.StartTime);
+                    return getLastSnappableHitObject(minTime);
+
+                case FruitCompositionTool _:
+                case JuiceStreamCompositionTool _:
+                    if (!CursorInPlacementArea)
+                        return null;
+
+                    if (EditorBeatmap.PlacementObject.Value is JuiceStream)
+                    {
+                        // Juice stream path is not subject to snapping.
+                        return null;
+                    }
+
+                    double timeAtCursor = ((CatchPlayfield)Playfield).TimeAtScreenSpacePosition(inputManager.CurrentState.Mouse.Position);
+                    return getLastSnappableHitObject(timeAtCursor);
+
+                default:
+                    return null;
+            }
+        }
+
+        private void updateDistanceSnapGrid()
+        {
+            if (distanceSnapToggle.Value != TernaryState.True)
+            {
+                distanceSnapGrid.Hide();
+                return;
+            }
+
+            var sourceHitObject = getDistanceSnapGridSourceHitObject();
+
+            if (sourceHitObject == null)
+            {
+                distanceSnapGrid.Hide();
+                return;
+            }
+
+            distanceSnapGrid.Show();
+            distanceSnapGrid.StartTime = sourceHitObject.GetEndTime();
+            distanceSnapGrid.StartX = sourceHitObject.EffectiveX;
+        }
     }
 }

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

@@ -52,8 +52,8 @@ namespace osu.Game.Rulesets.Catch.Mods
         {
             var hitObject = drawable.HitObject;
 
-            var offset = hitObject.TimePreempt * fade_out_offset_multiplier;
+            double offset = hitObject.TimePreempt * fade_out_offset_multiplier;
-            var duration = offset - hitObject.TimePreempt * fade_out_duration_multiplier;
+            double duration = offset - hitObject.TimePreempt * fade_out_duration_multiplier;
 
             using (drawable.BeginAbsoluteSequence(hitObject.StartTime - offset))
                 drawable.FadeOut(duration);

osu.Game.Rulesets.Catch/Replays/CatchAutoGenerator.cs

@@ -26,9 +26,6 @@ namespace osu.Game.Rulesets.Catch.Replays
             if (Beatmap.HitObjects.Count == 0)
                 return;
 
-            // todo: add support for HT DT
-            const double dash_speed = Catcher.BASE_SPEED;
-            const double movement_speed = dash_speed / 2;
             float lastPosition = CatchPlayfield.CENTER_X;
             double lastTime = 0;
 
@@ -47,8 +44,8 @@ namespace osu.Game.Rulesets.Catch.Replays
                 // The case where positionChange > 0 and timeAvailable == 0 results in PositiveInfinity which provides expected beheaviour.
                 double speedRequired = positionChange == 0 ? 0 : positionChange / timeAvailable;
 
-                bool dashRequired = speedRequired > movement_speed;
+                bool dashRequired = speedRequired > Catcher.BASE_WALK_SPEED;
-                bool impossibleJump = speedRequired > movement_speed * 2;
+                bool impossibleJump = speedRequired > Catcher.BASE_DASH_SPEED;
 
                 // todo: get correct catcher size, based on difficulty CS.
                 const float catcher_width_half = Catcher.BASE_SIZE * 0.3f * 0.5f;
@@ -73,7 +70,7 @@ namespace osu.Game.Rulesets.Catch.Replays
                 else if (dashRequired)
                 {
                     // we do a movement in two parts - the dash part then the normal part...
-                    double timeAtNormalSpeed = positionChange / movement_speed;
+                    double timeAtNormalSpeed = positionChange / Catcher.BASE_WALK_SPEED;
                     double timeWeNeedToSave = timeAtNormalSpeed - timeAvailable;
                     double timeAtDashSpeed = timeWeNeedToSave / 2;
 
@@ -86,7 +83,7 @@ namespace osu.Game.Rulesets.Catch.Replays
                 }
                 else
                 {
-                    double timeBefore = positionChange / movement_speed;
+                    double timeBefore = positionChange / Catcher.BASE_WALK_SPEED;
 
                     addFrame(h.StartTime - timeBefore, lastPosition);
                     addFrame(h.StartTime, h.EffectiveX);

osu.Game.Rulesets.Catch/Replays/CatchFramedReplayInputHandler.cs

@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Catch.Replays
 
         public override void CollectPendingInputs(List<IInput> inputs)
         {
-            var position = Interpolation.ValueAt(CurrentTime, StartFrame.Position, EndFrame.Position, StartFrame.Time, EndFrame.Time);
+            float position = Interpolation.ValueAt(CurrentTime, StartFrame.Position, EndFrame.Position, StartFrame.Time, EndFrame.Time);
 
             inputs.Add(new CatchReplayState
             {

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

@@ -66,7 +66,7 @@ namespace osu.Game.Rulesets.Catch.Skinning.Legacy
                         return null;
 
                     case CatchSkinComponents.Catcher:
-                        var version = GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value ?? 1;
+                        decimal version = GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value ?? 1;
 
                         if (version < 2.3m)
                         {

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

@@ -57,14 +57,19 @@ namespace osu.Game.Rulesets.Catch.UI
         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.
+        /// The speed of the catcher when the catcher is dashing.
         /// </summary>
-        public const double BASE_SPEED = 1.0;
+        public const double BASE_DASH_SPEED = 1.0;
 
         /// <summary>
-        /// The current speed of the catcher.
+        /// The speed of the catcher when the catcher is not dashing.
         /// </summary>
-        public double Speed => (Dashing ? 1 : 0.5) * BASE_SPEED * hyperDashModifier;
+        public const double BASE_WALK_SPEED = 0.5;
+
+        /// <summary>
+        /// The current speed of the catcher with the hyper-dash modifier applied.
+        /// </summary>
+        public double Speed => (Dashing ? BASE_DASH_SPEED : BASE_WALK_SPEED) * hyperDashModifier;
 
         /// <summary>
         /// The amount by which caught fruit should be scaled down to fit on the plate.
@@ -226,11 +231,11 @@ namespace osu.Game.Rulesets.Catch.UI
             if (result.IsHit && hitObject.HyperDash)
             {
                 var target = hitObject.HyperDashTarget;
-                var timeDifference = target.StartTime - hitObject.StartTime;
+                double timeDifference = target.StartTime - hitObject.StartTime;
                 double positionDifference = target.EffectiveX - X;
-                var velocity = positionDifference / Math.Max(1.0, timeDifference - 1000.0 / 60.0);
+                double velocity = positionDifference / Math.Max(1.0, timeDifference - 1000.0 / 60.0);
 
-                SetHyperDashState(Math.Abs(velocity), target.EffectiveX);
+                SetHyperDashState(Math.Abs(velocity) / BASE_DASH_SPEED, target.EffectiveX);
             }
             else
                 SetHyperDashState();
@@ -266,7 +271,7 @@ namespace osu.Game.Rulesets.Catch.UI
         /// <param name="targetPosition">When this catcher crosses this position, this catcher ends hyper-dashing.</param>
         public void SetHyperDashState(double modifier = 1, float targetPosition = -1)
         {
-            var wasHyperDashing = HyperDashing;
+            bool wasHyperDashing = HyperDashing;
 
             if (modifier <= 1 || X == targetPosition)
             {

osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs

@@ -43,7 +43,7 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor
 
         protected override SnapResult SnapForBlueprint(PlacementBlueprint blueprint)
         {
-            var time = column.TimeAtScreenSpacePosition(InputManager.CurrentState.Mouse.Position);
+            double time = column.TimeAtScreenSpacePosition(InputManager.CurrentState.Mouse.Position);
             var pos = column.ScreenSpacePositionAtTime(time);
 
             return new SnapResult(pos, time, column);

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

@@ -111,7 +111,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 
         public int CompareTo(ConvertValue other)
         {
-            var result = StartTime.CompareTo(other.StartTime);
+            int result = StartTime.CompareTo(other.StartTime);
 
             if (result != 0)
                 return result;

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

@@ -43,7 +43,7 @@ namespace osu.Game.Rulesets.Mania.Tests
 
         private IEnumerable<ColumnType> getResults(StageDefinition definition)
         {
-            for (var i = 0; i < definition.Columns; i++)
+            for (int i = 0; i < definition.Columns; i++)
                 yield return definition.GetTypeOfColumn(i);
         }
     }

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

@@ -42,8 +42,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         {
             IsForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.Equals(ruleset.RulesetInfo);
 
-            var roundedCircleSize = Math.Round(beatmap.Difficulty.CircleSize);
+            double roundedCircleSize = Math.Round(beatmap.Difficulty.CircleSize);
-            var roundedOverallDifficulty = Math.Round(beatmap.Difficulty.OverallDifficulty);
+            double roundedOverallDifficulty = Math.Round(beatmap.Difficulty.OverallDifficulty);
 
             if (IsForCurrentRuleset)
             {
@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
         public static int GetColumnCountForNonConvert(BeatmapInfo beatmapInfo)
         {
-            var roundedCircleSize = Math.Round(beatmapInfo.BaseDifficulty.CircleSize);
+            double roundedCircleSize = Math.Round(beatmapInfo.BaseDifficulty.CircleSize);
             return (int)Math.Max(1, roundedCircleSize);
         }
 

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

@@ -493,7 +493,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             if (!(HitObject is IHasPathWithRepeats curveData))
                 return null;
 
-            var index = SegmentDuration == 0 ? 0 : (time - StartTime) / SegmentDuration;
+            int index = SegmentDuration == 0 ? 0 : (time - StartTime) / SegmentDuration;
 
             // avoid slicing the list & creating copies, if at all possible.
             return index == 0 ? curveData.NodeSamples : curveData.NodeSamples.Skip(index).ToList();

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

@@ -302,7 +302,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             var pattern = new Pattern();
 
-            int noteCount = getRandomNoteCountMirrored(centreProbability, p2, p3, out var addToCentre);
+            int noteCount = getRandomNoteCountMirrored(centreProbability, p2, p3, out bool addToCentre);
 
             int columnLimit = (TotalColumns % 2 == 0 ? TotalColumns : TotalColumns - 1) / 2;
             int nextColumn = GetRandomColumn(upperBound: columnLimit);

osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs

@@ -35,8 +35,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
         protected override double StrainValueOf(DifficultyHitObject current)
         {
             var maniaCurrent = (ManiaDifficultyHitObject)current;
-            var endTime = maniaCurrent.EndTime;
+            double endTime = maniaCurrent.EndTime;
-            var column = maniaCurrent.BaseObject.Column;
+            int column = maniaCurrent.BaseObject.Column;
 
             double holdFactor = 1.0; // Factor to all additional strains in case something else is held
             double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -316,7 +316,7 @@ namespace osu.Game.Rulesets.Mania
 
                 case PlayfieldType.Dual:
                 {
-                    var keys = getDualStageKeyCount(variant);
+                    int keys = getDualStageKeyCount(variant);
                     return $"{keys}K + {keys}K";
                 }
             }

osu.Game.Rulesets.Mania/MathUtils/LegacySortHelper.cs

@@ -62,9 +62,7 @@ namespace osu.Game.Rulesets.Mania.MathUtils
 
                     if (i < j)
                     {
-                        T key = keys[i];
+                        (keys[i], keys[j]) = (keys[j], keys[i]);
-                        keys[i] = keys[j];
-                        keys[j] = key;
                     }
 
                     i++;
@@ -122,7 +120,7 @@ namespace osu.Game.Rulesets.Mania.MathUtils
 
             while (i <= n / 2)
             {
-                var child = 2 * i;
+                int child = 2 * i;
 
                 if (child < n && comparer.Compare(keys[lo + child - 1], keys[lo + child]) < 0)
                 {
@@ -142,11 +140,7 @@ namespace osu.Game.Rulesets.Mania.MathUtils
         private static void swap(T[] a, int i, int j)
         {
             if (i != j)
-            {
+                (a[i], a[j]) = (a[j], a[i]);
-                T t = a[i];
-                a[i] = a[j];
-                a[j] = t;
-            }
         }
 
         private static void swapIfGreater(T[] keys, IComparer<T> comparer, int a, int b)
@@ -154,11 +148,7 @@ namespace osu.Game.Rulesets.Mania.MathUtils
             if (a != b)
             {
                 if (comparer.Compare(keys[a], keys[b]) > 0)
-                {
+                    (keys[a], keys[b]) = (keys[b], keys[a]);
-                    T key = keys[a];
-                    keys[a] = keys[b];
-                    keys[b] = key;
-                }
             }
         }
     }

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Mania.Mods
 
         public void ApplyToBeatmap(IBeatmap beatmap)
         {
-            var availableColumns = ((ManiaBeatmap)beatmap).TotalColumns;
+            int availableColumns = ((ManiaBeatmap)beatmap).TotalColumns;
 
             beatmap.HitObjects.OfType<ManiaHitObject>().ForEach(h => h.Column = availableColumns - 1 - h.Column);
         }

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

@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Mania.Mods
             Seed.Value ??= RNG.Next();
             var rng = new Random((int)Seed.Value);
 
-            var availableColumns = ((ManiaBeatmap)beatmap).TotalColumns;
+            int availableColumns = ((ManiaBeatmap)beatmap).TotalColumns;
             var shuffledColumns = Enumerable.Range(0, availableColumns).OrderBy(item => rng.Next()).ToList();
 
             beatmap.HitObjects.OfType<ManiaHitObject>().ForEach(h => h.Column = shuffledColumns[h.Column]);

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

@@ -97,7 +97,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (Time.Current < HitObject.StartTime)
                 return;
 
-            var startTime = holdStartTime?.Invoke();
+            double? startTime = holdStartTime?.Invoke();
 
             if (startTime == null || startTime > HitObject.StartTime)
                 ApplyResult(r => r.Type = r.Judgement.MinResult);

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

@@ -75,7 +75,7 @@ namespace osu.Game.Rulesets.Mania.Replays
             {
                 var currentObject = Beatmap.HitObjects[i];
                 var nextObjectInColumn = GetNextObject(i); // Get the next object that requires pressing the same button
-                var releaseTime = calculateReleaseTime(currentObject, nextObjectInColumn);
+                double releaseTime = calculateReleaseTime(currentObject, nextObjectInColumn);
 
                 yield return new HitPoint { Time = currentObject.StartTime, Column = currentObject.Column };
 

osu.Game.Rulesets.Mania/Skinning/Legacy/ManiaLegacySkinTransformer.cs

@@ -66,7 +66,7 @@ namespace osu.Game.Rulesets.Mania.Skinning.Legacy
             isLegacySkin = new Lazy<bool>(() => GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version) != null);
             hasKeyTexture = new Lazy<bool>(() =>
             {
-                var keyImage = this.GetManiaSkinConfig<string>(LegacyManiaSkinConfigurationLookups.KeyImage, 0)?.Value ?? "mania-key1";
+                string keyImage = this.GetManiaSkinConfig<string>(LegacyManiaSkinConfigurationLookups.KeyImage, 0)?.Value ?? "mania-key1";
                 return this.GetAnimation(keyImage, true, true) != null;
             });
         }

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModHidden.cs

@@ -117,6 +117,42 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
             PassCondition = checkSomeHit
         });
 
+        [Test]
+        public void TestApproachCirclesOnly() => CreateModTest(new ModTestData
+        {
+            Mod = new OsuModHidden { OnlyFadeApproachCircles = { Value = true } },
+            Autoplay = true,
+            Beatmap = new Beatmap
+            {
+                HitObjects = new List<HitObject>
+                {
+                    new HitCircle
+                    {
+                        StartTime = 1000,
+                        Position = new Vector2(206, 142)
+                    },
+                    new HitCircle
+                    {
+                        StartTime = 2000,
+                        Position = new Vector2(306, 142)
+                    },
+                    new Slider
+                    {
+                        StartTime = 3000,
+                        Position = new Vector2(156, 242),
+                        Path = new SliderPath(PathType.Linear, new[] { Vector2.Zero, new Vector2(200, 0), })
+                    },
+                    new Spinner
+                    {
+                        Position = new Vector2(256, 192),
+                        StartTime = 7000,
+                        EndTime = 9000
+                    }
+                }
+            },
+            PassCondition = checkSomeHit
+        });
+
         private bool checkSomeHit() => Player.ScoreProcessor.JudgedHits >= 4;
 
         private bool objectWithIncreasedVisibilityHasIndex(int index)

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModNoScope.cs

@@ -0,0 +1,150 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Utils;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Tests.Mods
+{
+    public class TestSceneOsuModNoScope : OsuModTestScene
+    {
+        [Test]
+        public void TestVisibleDuringBreak()
+        {
+            CreateModTest(new ModTestData
+            {
+                Mod = new OsuModNoScope
+                {
+                    HiddenComboCount = { Value = 0 },
+                },
+                Autoplay = true,
+                PassCondition = () => true,
+                Beatmap = new Beatmap
+                {
+                    HitObjects = new List<HitObject>
+                    {
+                        new HitCircle
+                        {
+                            Position = new Vector2(300, 192),
+                            StartTime = 1000,
+                        },
+                        new HitCircle
+                        {
+                            Position = new Vector2(300, 192),
+                            StartTime = 5000,
+                        }
+                    },
+                    Breaks = new List<BreakPeriod>
+                    {
+                        new BreakPeriod(2000, 4000),
+                    }
+                }
+            });
+
+            AddUntilStep("wait for cursor to hide", () => cursorAlphaAlmostEquals(0));
+            AddUntilStep("wait for start of break", isBreak);
+            AddUntilStep("wait for cursor to show", () => cursorAlphaAlmostEquals(1));
+            AddUntilStep("wait for end of break", () => !isBreak());
+            AddUntilStep("wait for cursor to hide", () => cursorAlphaAlmostEquals(0));
+        }
+
+        [Test]
+        public void TestVisibleDuringSpinner()
+        {
+            CreateModTest(new ModTestData
+            {
+                Mod = new OsuModNoScope
+                {
+                    HiddenComboCount = { Value = 0 },
+                },
+                Autoplay = true,
+                PassCondition = () => true,
+                Beatmap = new Beatmap
+                {
+                    HitObjects = new List<HitObject>
+                    {
+                        new HitCircle
+                        {
+                            Position = new Vector2(300, 192),
+                            StartTime = 1000,
+                        },
+                        new Spinner
+                        {
+                            Position = new Vector2(256, 192),
+                            StartTime = 2000,
+                            Duration = 2000,
+                        },
+                        new HitCircle
+                        {
+                            Position = new Vector2(300, 192),
+                            StartTime = 5000,
+                        }
+                    }
+                }
+            });
+
+            AddUntilStep("wait for cursor to hide", () => cursorAlphaAlmostEquals(0));
+            AddUntilStep("wait for start of spinner", isSpinning);
+            AddUntilStep("wait for cursor to show", () => cursorAlphaAlmostEquals(1));
+            AddUntilStep("wait for end of spinner", () => !isSpinning());
+            AddUntilStep("wait for cursor to hide", () => cursorAlphaAlmostEquals(0));
+        }
+
+        [Test]
+        public void TestVisibleAfterComboBreak()
+        {
+            CreateModTest(new ModTestData
+            {
+                Mod = new OsuModNoScope
+                {
+                    HiddenComboCount = { Value = 2 },
+                },
+                Autoplay = true,
+                PassCondition = () => true,
+                Beatmap = new Beatmap
+                {
+                    HitObjects = new List<HitObject>
+                    {
+                        new HitCircle
+                        {
+                            Position = new Vector2(100, 192),
+                            StartTime = 1000,
+                        },
+                        new HitCircle
+                        {
+                            Position = new Vector2(150, 192),
+                            StartTime = 3000,
+                        },
+                        new HitCircle
+                        {
+                            Position = new Vector2(200, 192),
+                            StartTime = 5000,
+                        },
+                    }
+                }
+            });
+
+            AddAssert("cursor must start visible", () => cursorAlphaAlmostEquals(1));
+            AddUntilStep("wait for combo", () => Player.ScoreProcessor.Combo.Value >= 2);
+            AddAssert("cursor must dim after combo", () => !cursorAlphaAlmostEquals(1));
+            AddStep("break combo", () => Player.ScoreProcessor.Combo.Set(0));
+            AddUntilStep("wait for cursor to show", () => cursorAlphaAlmostEquals(1));
+        }
+
+        private bool isSpinning() => Player.ChildrenOfType<DrawableSpinner>().SingleOrDefault()?.Progress > 0;
+
+        private bool isBreak() => Player.IsBreakTime.Value;
+
+        private bool cursorAlphaAlmostEquals(float alpha) => Precision.AlmostEquals(Player.DrawableRuleset.Cursor.Alpha, alpha);
+    }
+}

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

@@ -97,7 +97,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private void scheduleHit() => AddStep("schedule action", () =>
         {
-            var delay = hitCircle.StartTime - hitCircle.HitWindows.WindowFor(HitResult.Great) - Time.Current;
+            double delay = hitCircle.StartTime - hitCircle.HitWindows.WindowFor(HitResult.Great) - Time.Current;
             Scheduler.AddDelayed(() => hitAreaReceptor.OnPressed(new KeyBindingPressEvent<OsuAction>(GetContainingInputManager().CurrentState, OsuAction.LeftButton)), delay);
         });
     }

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

@@ -148,7 +148,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("player score matching expected bonus score", () =>
             {
                 // multipled by 2 to nullify the score multiplier. (autoplay mod selected)
-                var totalScore = ((ScoreExposedPlayer)Player).ScoreProcessor.TotalScore.Value * 2;
+                double totalScore = ((ScoreExposedPlayer)Player).ScoreProcessor.TotalScore.Value * 2;
                 return totalScore == (int)(drawableSpinner.Result.RateAdjustedRotation / 360) * new SpinnerTick().CreateJudgement().MaxNumericResult;
             });
 

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

@@ -123,7 +123,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
 
             // Skip the head circle
             var scoringTimes = slider.NestedHitObjects.Skip(1).Select(t => t.StartTime);
-            foreach (var time in scoringTimes)
+            foreach (double time in scoringTimes)
                 computeVertex(time);
         }
 

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

@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
                 {
                     const double scale = 90;
 
-                    var angleBonus = Math.Sqrt(
+                    double angleBonus = Math.Sqrt(
                         Math.Max(osuPrevious.JumpDistance - scale, 0)
                         * Math.Pow(Math.Sin(osuCurrent.Angle.Value - angle_bonus_begin), 2)
                         * Math.Max(osuCurrent.JumpDistance - scale, 0));

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs

@@ -184,7 +184,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
         {
             Vector2[] oldControlPoints = slider.Path.ControlPoints.Select(cp => cp.Position).ToArray();
             var oldPosition = slider.Position;
-            var oldStartTime = slider.StartTime;
+            double oldStartTime = slider.StartTime;
 
             if (ControlPoint == slider.Path.ControlPoints[0])
             {
@@ -205,7 +205,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
             if (!slider.Path.HasValidLength)
             {
-                for (var i = 0; i < slider.Path.ControlPoints.Count; i++)
+                for (int i = 0; i < slider.Path.ControlPoints.Count; i++)
                     slider.Path.ControlPoints[i].Position = oldControlPoints[i];
 
                 slider.Position = oldPosition;

osu.Game.Rulesets.Osu/Edit/Checks/CheckLowDiffOverlaps.cs

@@ -47,14 +47,14 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
                 if (!(hitObjects[i + 1] is OsuHitObject nextHitObject) || nextHitObject is Spinner)
                     continue;
 
-                var deltaTime = nextHitObject.StartTime - hitObject.GetEndTime();
+                double deltaTime = nextHitObject.StartTime - hitObject.GetEndTime();
                 if (deltaTime >= hitObject.TimeFadeIn + hitObject.TimePreempt)
                     // The objects are not visible at the same time (without mods), hence skipping.
                     continue;
 
-                var distanceSq = (hitObject.StackedEndPosition - nextHitObject.StackedPosition).LengthSquared;
+                float distanceSq = (hitObject.StackedEndPosition - nextHitObject.StackedPosition).LengthSquared;
-                var diameter = (hitObject.Radius - overlap_leniency) * 2;
+                double diameter = (hitObject.Radius - overlap_leniency) * 2;
-                var diameterSq = diameter * diameter;
+                double diameterSq = diameter * diameter;
 
                 bool areOverlapping = distanceSq < diameterSq;
 

osu.Game.Rulesets.Osu/Edit/Checks/CheckTimeDistanceEquality.cs

@@ -88,21 +88,21 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
                 if (!(hitObjects[i + 1] is OsuHitObject nextHitObject) || nextHitObject is Spinner)
                     continue;
 
-                var deltaTime = nextHitObject.StartTime - hitObject.GetEndTime();
+                double deltaTime = nextHitObject.StartTime - hitObject.GetEndTime();
 
                 // Ignore objects that are far enough apart in time to not be considered the same pattern.
                 if (deltaTime > pattern_lifetime)
                     continue;
 
                 // Relying on FastInvSqrt is probably good enough here. We'll be taking the difference between distances later, hence square not being sufficient.
-                var distance = (hitObject.StackedEndPosition - nextHitObject.StackedPosition).LengthFast;
+                float distance = (hitObject.StackedEndPosition - nextHitObject.StackedPosition).LengthFast;
 
                 // Ignore stacks and half-stacks, as these are close enough to where they can't be confused for being time-distanced.
                 if (distance < stack_leniency)
                     continue;
 
                 var observedTimeDistance = new ObservedTimeDistance(nextHitObject.StartTime, deltaTime, distance);
-                var expectedDistance = getExpectedDistance(prevObservedTimeDistances, observedTimeDistance);
+                double expectedDistance = getExpectedDistance(prevObservedTimeDistances, observedTimeDistance);
 
                 if (expectedDistance == 0)
                 {
@@ -125,7 +125,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Checks
 
         private double getExpectedDistance(IEnumerable<ObservedTimeDistance> prevObservedTimeDistances, ObservedTimeDistance observedTimeDistance)
         {
-            var observations = prevObservedTimeDistances.Count();
+            int observations = prevObservedTimeDistances.Count();
 
             int count = 0;
             double sum = 0;

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

@@ -30,7 +30,7 @@ namespace osu.Game.Rulesets.Osu.Edit
         [BackgroundDependencyLoader]
         private void load()
         {
-            var gridSizeIndex = Array.IndexOf(grid_sizes, editorBeatmap.BeatmapInfo.GridSize);
+            int gridSizeIndex = Array.IndexOf(grid_sizes, editorBeatmap.BeatmapInfo.GridSize);
             if (gridSizeIndex >= 0)
                 currentGridSizeIndex = gridSizeIndex;
             updateSpacing();

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

@@ -170,7 +170,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                 base.LoadComplete();
 
                 var firstObj = beatmap.HitObjects[0];
-                var startDelay = firstObj.StartTime - firstObj.TimePreempt;
+                double startDelay = firstObj.StartTime - firstObj.TimePreempt;
 
                 using (BeginAbsoluteSequence(startDelay + break_close_late))
                     leaveBreak();

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

@@ -5,6 +5,8 @@ using System;
 using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Graphics;
+using osu.Framework.Bindables;
+using osu.Game.Configuration;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
@@ -17,6 +19,9 @@ namespace osu.Game.Rulesets.Osu.Mods
 {
     public class OsuModHidden : ModHidden, IHidesApproachCircles
     {
+        [SettingSource("Only fade approach circles", "The main object body will not fade when enabled.")]
+        public Bindable<bool> OnlyFadeApproachCircles { get; } = new BindableBool();
+
         public override string Description => @"Play with no approach circles and fading circles/sliders.";
         public override double ScoreMultiplier => 1.06;
 
@@ -44,15 +49,15 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         protected override void ApplyIncreasedVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
-            applyState(hitObject, true);
+            applyHiddenState(hitObject, true);
         }
 
         protected override void ApplyNormalVisibilityState(DrawableHitObject hitObject, ArmedState state)
         {
-            applyState(hitObject, false);
+            applyHiddenState(hitObject, false);
         }
 
-        private void applyState(DrawableHitObject drawableObject, bool increaseVisibility)
+        private void applyHiddenState(DrawableHitObject drawableObject, bool increaseVisibility)
         {
             if (!(drawableObject is DrawableOsuHitObject drawableOsuObject))
                 return;
@@ -61,6 +66,24 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             (double fadeStartTime, double fadeDuration) = getFadeOutParameters(drawableOsuObject);
 
+            // process approach circle hiding first (to allow for early return below).
+            if (!increaseVisibility)
+            {
+                if (drawableObject is DrawableHitCircle circle)
+                {
+                    using (circle.BeginAbsoluteSequence(hitObject.StartTime - hitObject.TimePreempt))
+                        circle.ApproachCircle.Hide();
+                }
+                else if (drawableObject is DrawableSpinner spinner)
+                {
+                    spinner.Body.OnSkinChanged += () => hideSpinnerApproachCircle(spinner);
+                    hideSpinnerApproachCircle(spinner);
+                }
+            }
+
+            if (OnlyFadeApproachCircles.Value)
+                return;
+
             switch (drawableObject)
             {
                 case DrawableSliderTail _:
@@ -84,12 +107,6 @@ namespace osu.Game.Rulesets.Osu.Mods
                         // only fade the circle piece (not the approach circle) for the increased visibility object.
                         fadeTarget = circle.CirclePiece;
                     }
-                    else
-                    {
-                        // we don't want to see the approach circle
-                        using (circle.BeginAbsoluteSequence(hitObject.StartTime - hitObject.TimePreempt))
-                            circle.ApproachCircle.Hide();
-                    }
 
                     using (drawableObject.BeginAbsoluteSequence(fadeStartTime))
                         fadeTarget.FadeOut(fadeDuration);
@@ -111,9 +128,6 @@ namespace osu.Game.Rulesets.Osu.Mods
                     // hide elements we don't care about.
                     // todo: hide background
 
-                    spinner.Body.OnSkinChanged += () => hideSpinnerApproachCircle(spinner);
-                    hideSpinnerApproachCircle(spinner);
-
                     using (spinner.BeginAbsoluteSequence(fadeStartTime))
                         spinner.FadeOut(fadeDuration);
 
@@ -141,11 +155,11 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             static (double fadeStartTime, double fadeDuration) getParameters(OsuHitObject hitObject)
             {
-                var fadeOutStartTime = hitObject.StartTime - hitObject.TimePreempt + hitObject.TimeFadeIn;
+                double fadeOutStartTime = hitObject.StartTime - hitObject.TimePreempt + hitObject.TimeFadeIn;
-                var fadeOutDuration = hitObject.TimePreempt * fade_out_duration_multiplier;
+                double fadeOutDuration = hitObject.TimePreempt * fade_out_duration_multiplier;
 
                 // new duration from completed fade in to end (before fading out)
-                var longFadeDuration = hitObject.GetEndTime() - fadeOutStartTime;
+                double longFadeDuration = hitObject.GetEndTime() - fadeOutStartTime;
 
                 switch (hitObject)
                 {
@@ -153,7 +167,7 @@ namespace osu.Game.Rulesets.Osu.Mods
                         return (fadeOutStartTime, longFadeDuration);
 
                     case SliderTick _:
-                        var tickFadeOutDuration = Math.Min(hitObject.TimePreempt - DrawableSliderTick.ANIM_DURATION, 1000);
+                        double tickFadeOutDuration = Math.Min(hitObject.TimePreempt - DrawableSliderTick.ANIM_DURATION, 1000);
                         return (hitObject.StartTime - tickFadeOutDuration, tickFadeOutDuration);
 
                     case Spinner _:

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

@@ -2,22 +2,27 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Game.Rulesets.UI;
+using System.Linq;
-using osu.Game.Rulesets.Mods;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Bindables;
 using osu.Framework.Localisation;
 using osu.Framework.Utils;
-using osu.Game.Graphics.UserInterface;
+using osu.Game.Beatmaps;
 using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Utils;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModNoScope : Mod, IUpdatableByPlayfield, IApplicableToScoreProcessor
+    public class OsuModNoScope : Mod, IUpdatableByPlayfield, IApplicableToScoreProcessor, IApplicableToPlayer, IApplicableToBeatmap
     {
         /// <summary>
         /// Slightly higher than the cutoff for <see cref="Drawable.IsPresent"/>.
@@ -34,8 +39,10 @@ namespace osu.Game.Rulesets.Osu.Mods
         public override double ScoreMultiplier => 1;
 
         private BindableNumber<int> currentCombo;
+        private IBindable<bool> isBreakTime;
+        private PeriodTracker spinnerPeriods;
 
-        private float targetAlpha;
+        private float comboBasedAlpha;
 
         [SettingSource(
             "Hidden at combo",
@@ -52,6 +59,16 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         public ScoreRank AdjustRank(ScoreRank rank, double accuracy) => rank;
 
+        public void ApplyToPlayer(Player player)
+        {
+            isBreakTime = player.IsBreakTime.GetBoundCopy();
+        }
+
+        public void ApplyToBeatmap(IBeatmap beatmap)
+        {
+            spinnerPeriods = new PeriodTracker(beatmap.HitObjects.OfType<Spinner>().Select(b => new Period(b.StartTime - transition_duration, b.EndTime)));
+        }
+
         public void ApplyToScoreProcessor(ScoreProcessor scoreProcessor)
         {
             if (HiddenComboCount.Value == 0) return;
@@ -59,12 +76,14 @@ namespace osu.Game.Rulesets.Osu.Mods
             currentCombo = scoreProcessor.Combo.GetBoundCopy();
             currentCombo.BindValueChanged(combo =>
             {
-                targetAlpha = Math.Max(min_alpha, 1 - (float)combo.NewValue / HiddenComboCount.Value);
+                comboBasedAlpha = Math.Max(min_alpha, 1 - (float)combo.NewValue / HiddenComboCount.Value);
             }, true);
         }
 
         public virtual void Update(Playfield playfield)
         {
+            bool shouldAlwaysShowCursor = isBreakTime.Value || spinnerPeriods.IsInAny(playfield.Clock.CurrentTime);
+            float targetAlpha = shouldAlwaysShowCursor ? 1 : comboBasedAlpha;
             playfield.Cursor.Alpha = (float)Interpolation.Lerp(playfield.Cursor.Alpha, targetAlpha, Math.Clamp(playfield.Time.Elapsed / transition_duration, 0, 1));
         }
     }

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

@@ -124,7 +124,7 @@ namespace osu.Game.Rulesets.Osu.Mods
             // to allow jumps and prevent too sharp turns during streams.
 
             // Allow maximum jump angle when jump distance is more than half of playfield diagonal length
-            var randomAngleRad = rateOfChangeMultiplier * 2 * Math.PI * Math.Min(1f, distanceToPrev / (playfield_diagonal * 0.5f));
+            double randomAngleRad = rateOfChangeMultiplier * 2 * Math.PI * Math.Min(1f, distanceToPrev / (playfield_diagonal * 0.5f));
 
             current.AngleRad = (float)randomAngleRad + previous.AngleRad;
             if (current.AngleRad < 0)
@@ -171,11 +171,11 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             // Clamp slider position to the placement area
             // If the slider is larger than the playfield, force it to stay at the original position
-            var newX = possibleMovementBounds.Width < 0
+            float newX = possibleMovementBounds.Width < 0
                 ? objectInfo.PositionOriginal.X
                 : Math.Clamp(previousPosition.X, possibleMovementBounds.Left, possibleMovementBounds.Right);
 
-            var newY = possibleMovementBounds.Height < 0
+            float newY = possibleMovementBounds.Height < 0
                 ? objectInfo.PositionOriginal.Y
                 : Math.Clamp(previousPosition.Y, possibleMovementBounds.Top, possibleMovementBounds.Bottom);
 
@@ -235,7 +235,7 @@ namespace osu.Game.Rulesets.Osu.Mods
             }
 
             // Take the circle radius into account.
-            var radius = (float)slider.Radius;
+            float radius = (float)slider.Radius;
 
             minX -= radius;
             minY -= radius;

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

@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Mods
             // because the spinner is under the gameplay clock, it is affected by rate adjustments on the track;
             // for that reason using ElapsedFrameTime directly leads to fewer SPM with Half Time and more SPM with Double Time.
             // for spinners we want the real (wall clock) elapsed time; to achieve that, unapply the clock rate locally here.
-            var rateIndependentElapsedTime = spinner.Clock.ElapsedFrameTime / spinner.Clock.Rate;
+            double rateIndependentElapsedTime = spinner.Clock.ElapsedFrameTime / spinner.Clock.Rate;
             spinner.RotationTracker.AddRotation(MathUtils.RadiansToDegrees((float)rateIndependentElapsedTime * 0.03f));
         }
     }

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

@@ -193,8 +193,8 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         private IEnumerable<double> generateBeats(IBeatmap beatmap)
         {
-            var startTime = originalHitObjects.First().StartTime;
+            double startTime = originalHitObjects.First().StartTime;
-            var endTime = originalHitObjects.Last().GetEndTime();
+            double endTime = originalHitObjects.Last().GetEndTime();
 
             var beats = beatmap.ControlPointInfo.TimingPoints
                                // Ignore timing points after endTime
@@ -208,9 +208,9 @@ namespace osu.Game.Rulesets.Osu.Mods
                                .ToList();
 
             // Remove beats that are too close to the next one (e.g. due to timing point changes)
-            for (var i = beats.Count - 2; i >= 0; i--)
+            for (int i = beats.Count - 2; i >= 0; i--)
             {
-                var beat = beats[i];
+                double beat = beats[i];
 
                 if (!definitelyBigger(beats[i + 1] - beat, beatmap.ControlPointInfo.TimingPointAt(beat).BeatLength / 2))
                     beats.RemoveAt(i);
@@ -250,13 +250,13 @@ namespace osu.Game.Rulesets.Osu.Mods
             // Other kinds of combo info are also added in the process
             var combos = hitObjects.GroupBy(x => x.ComboIndex).ToList();
 
-            for (var i = 0; i < combos.Count; i++)
+            for (int i = 0; i < combos.Count; i++)
             {
                 var group = combos[i].ToList();
                 group.First().NewCombo = true;
                 group.Last().LastInCombo = true;
 
-                for (var j = 0; j < group.Count; j++)
+                for (int j = 0; j < group.Count; j++)
                 {
                     var x = group[j];
                     x.ComboIndex = i;
@@ -273,17 +273,17 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             const float two_pi = MathF.PI * 2;
 
-            var direction = two_pi * nextSingle();
+            float direction = two_pi * nextSingle();
-            var maxComboIndex = hitObjects.Last().ComboIndex;
+            int maxComboIndex = hitObjects.Last().ComboIndex;
 
-            for (var i = 0; i < hitObjects.Count; i++)
+            for (int i = 0; i < hitObjects.Count; i++)
             {
                 var obj = hitObjects[i];
                 var lastPos = i == 0
                     ? Vector2.Divide(OsuPlayfield.BASE_SIZE, 2)
                     : hitObjects[i - 1].Position;
 
-                var distance = maxComboIndex == 0
+                float distance = maxComboIndex == 0
                     ? (float)obj.Radius
                     : mapRange(obj.ComboIndex, 0, maxComboIndex, (float)obj.Radius, max_base_distance);
                 if (obj.NewCombo) distance *= 1.5f;
@@ -292,7 +292,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
                 // Attempt to place the circle at a place that does not overlap with previous ones
 
-                var tryCount = 0;
+                int tryCount = 0;
 
                 // for checking overlap
                 var precedingObjects = hitObjects.SkipLast(hitObjects.Count - i).TakeLast(overlap_check_count).ToList();
@@ -363,7 +363,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         {
             var beats = new List<double>();
             int i = 0;
-            var currentTime = timingPoint.Time;
+            double currentTime = timingPoint.Time;
 
             while (!definitelyBigger(currentTime, mapEndTime) && controlPointInfo.TimingPointAt(currentTime) == timingPoint)
             {
@@ -377,7 +377,7 @@ namespace osu.Game.Rulesets.Osu.Mods
 
         private OsuHitObject getClosestHitObject(List<OsuHitObject> hitObjects, double time)
         {
-            var precedingIndex = hitObjects.FindLastIndex(h => h.StartTime < time);
+            int precedingIndex = hitObjects.FindLastIndex(h => h.StartTime < time);
 
             if (precedingIndex == hitObjects.Count - 1) return hitObjects[precedingIndex];
 
@@ -457,7 +457,7 @@ namespace osu.Game.Rulesets.Osu.Mods
         private void clampToPlayfield(OsuHitObject obj)
         {
             var position = obj.Position;
-            var radius = (float)obj.Radius;
+            float radius = (float)obj.Radius;
 
             if (position.Y < radius)
                 position.Y = radius;

osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointConnection.cs

@@ -67,7 +67,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
                 Vector2 pointStartPosition = startPosition + (fraction - 0.1f) * distanceVector;
                 Vector2 pointEndPosition = startPosition + fraction * distanceVector;
 
-                GetFadeTimes(start, end, (float)d / distance, out var fadeInTime, out var fadeOutTime);
+                GetFadeTimes(start, end, (float)d / distance, out double fadeInTime, out double fadeOutTime);
 
                 FollowPoint fp;
 

osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointLifetimeEntry.cs

@@ -93,7 +93,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
 
             // The lifetime start will match the fade-in time of the first follow point.
             float fraction = (int)(FollowPointConnection.SPACING * 1.5) / distanceVector.Length;
-            FollowPointConnection.GetFadeTimes(Start, End, fraction, out var fadeInTime, out _);
+            FollowPointConnection.GetFadeTimes(Start, End, fraction, out double fadeInTime, out _);
 
             LifetimeStart = fadeInTime;
             LifetimeEnd = double.MaxValue; // This will be set by the connection.

osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPointRenderer.cs

@@ -56,7 +56,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
         {
             var newEntry = new FollowPointLifetimeEntry(hitObject);
 
-            var index = lifetimeEntries.AddInPlace(newEntry, Comparer<FollowPointLifetimeEntry>.Create((e1, e2) =>
+            int index = lifetimeEntries.AddInPlace(newEntry, Comparer<FollowPointLifetimeEntry>.Create((e1, e2) =>
             {
                 int comp = e1.Start.StartTime.CompareTo(e2.Start.StartTime);
 

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

@@ -151,8 +151,9 @@ namespace osu.Game.Rulesets.Osu.Objects
         {
             base.CreateNestedHitObjects(cancellationToken);
 
-            foreach (var e in
+            var sliderEvents = SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset, cancellationToken);
-                SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset, cancellationToken))
+
+            foreach (var e in sliderEvents)
             {
                 switch (e.Type)
                 {

osu.Game.Rulesets.Osu/Skinning/Default/SnakingSliderBody.cs

@@ -70,8 +70,8 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
 
             Slider slider = drawableSlider.HitObject;
 
-            var span = slider.SpanAt(completionProgress);
+            int span = slider.SpanAt(completionProgress);
-            var spanProgress = slider.ProgressAt(completionProgress);
+            double spanProgress = slider.ProgressAt(completionProgress);
 
             double start = 0;
             double end = SnakingIn.Value ? Math.Clamp((Time.Current - (slider.StartTime - slider.TimePreempt)) / (slider.TimePreempt / 3), 0, 1) : 1;
@@ -110,8 +110,8 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
             snakedPosition = Path.PositionInBoundingBox(Vector2.Zero);
             snakedPathOffset = Path.PositionInBoundingBox(Path.Vertices[0]);
 
-            var lastSnakedStart = SnakedStart ?? 0;
+            double lastSnakedStart = SnakedStart ?? 0;
-            var lastSnakedEnd = SnakedEnd ?? 0;
+            double lastSnakedEnd = SnakedEnd ?? 0;
 
             SnakedStart = null;
             SnakedEnd = null;

osu.Game.Rulesets.Osu/Skinning/Default/SpinnerRotationTracker.cs

@@ -62,9 +62,9 @@ namespace osu.Game.Rulesets.Osu.Skinning.Default
         protected override void Update()
         {
             base.Update();
-            var thisAngle = -MathUtils.RadiansToDegrees(MathF.Atan2(mousePosition.X - DrawSize.X / 2, mousePosition.Y - DrawSize.Y / 2));
+            float thisAngle = -MathUtils.RadiansToDegrees(MathF.Atan2(mousePosition.X - DrawSize.X / 2, mousePosition.Y - DrawSize.Y / 2));
 
-            var delta = thisAngle - lastAngle;
+            float delta = thisAngle - lastAngle;
 
             if (Tracking)
                 AddRotation(delta);

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

@@ -157,7 +157,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
                         if (hasNumber)
                         {
-                            var legacyVersion = skin.GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value;
+                            decimal? legacyVersion = skin.GetConfig<SkinConfiguration.LegacySetting, decimal>(SkinConfiguration.LegacySetting.Version)?.Value;
 
                             if (legacyVersion >= 2.0m)
                                 // legacy skins of version 2.0 and newer only apply very short fade out to the number piece.

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

@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Osu.Skinning.Legacy
 
             // careful: need to call this exactly once for all calculations in a frame
             // as the function has a random factor in it
-            var metreHeight = getMetreHeight(DrawableSpinner.Progress);
+            float metreHeight = getMetreHeight(DrawableSpinner.Progress);
 
             // hack to make the metre blink up from below than down from above.
             // move down the container to be able to apply masking for the metre,

osu.Game.Rulesets.Osu/Statistics/AccuracyHeatmap.cs

@@ -216,7 +216,7 @@ namespace osu.Game.Rulesets.Osu.Statistics
             // Likewise sin(pi/2)=1 and sin(3pi/2)=-1, whereas we actually want these values to appear on the bottom/top respectively, so the y-coordinate also needs to be inverted.
             //
             // We also need to apply the anti-clockwise rotation.
-            var rotatedAngle = finalAngle - MathUtils.DegreesToRadians(rotation);
+            double rotatedAngle = finalAngle - MathUtils.DegreesToRadians(rotation);
             var rotatedCoordinate = -1 * new Vector2((float)Math.Cos(rotatedAngle), (float)Math.Sin(rotatedAngle));
 
             Vector2 localCentre = new Vector2(points_per_dimension - 1) / 2;

osu.Game.Rulesets.Osu/Utils/OsuHitObjectGenerationUtils.cs

@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Osu.Utils
         /// <returns>The new position of the hit object, relative to the previous one.</returns>
         public static Vector2 RotateAwayFromEdge(Vector2 prevObjectPos, Vector2 posRelativeToPrev, float rotationRatio = 0.5f)
         {
-            var relativeRotationDistance = 0f;
+            float relativeRotationDistance = 0f;
 
             if (prevObjectPos.X < playfield_middle.X)
             {
@@ -88,16 +88,16 @@ namespace osu.Game.Rulesets.Osu.Utils
         /// <returns>The rotated vector.</returns>
         public static Vector2 RotateVectorTowardsVector(Vector2 initial, Vector2 destination, float rotationRatio)
         {
-            var initialAngleRad = MathF.Atan2(initial.Y, initial.X);
+            float initialAngleRad = MathF.Atan2(initial.Y, initial.X);
-            var destAngleRad = MathF.Atan2(destination.Y, destination.X);
+            float destAngleRad = MathF.Atan2(destination.Y, destination.X);
 
-            var diff = destAngleRad - initialAngleRad;
+            float diff = destAngleRad - initialAngleRad;
 
             while (diff < -MathF.PI) diff += 2 * MathF.PI;
 
             while (diff > MathF.PI) diff -= 2 * MathF.PI;
 
-            var finalAngleRad = initialAngleRad + rotationRatio * diff;
+            float finalAngleRad = initialAngleRad + rotationRatio * diff;
 
             return new Vector2(
                 initial.Length * MathF.Cos(finalAngleRad),

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

@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
         {
             base.SetUpSteps();
 
-            var expectedSampleNames = new[]
+            string[] expectedSampleNames =
             {
                 string.Empty,
                 string.Empty,
@@ -31,6 +31,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
                 HitSampleInfo.HIT_WHISTLE,
                 HitSampleInfo.HIT_WHISTLE,
             };
+
             var actualSampleNames = new List<string>();
 
             // due to pooling we can't access all samples right away due to object re-use,

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs

@@ -79,7 +79,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
             {
                 case IHasDistance distanceData:
                 {
-                    if (shouldConvertSliderToHits(obj, beatmap, distanceData, out var taikoDuration, out var tickSpacing))
+                    if (shouldConvertSliderToHits(obj, beatmap, distanceData, out int taikoDuration, out double tickSpacing))
                     {
                         List<IList<HitSampleInfo>> allSamples = obj is IHasPathWithRepeats curveData ? curveData.NodeSamples : new List<IList<HitSampleInfo>>(new[] { samples });
 

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

@@ -109,7 +109,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
                 var corrected = samples.ToList();
 
-                for (var i = 0; i < corrected.Count; i++)
+                for (int i = 0; i < corrected.Count; i++)
                 {
                     var s = corrected[i];
 
@@ -156,7 +156,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             validActionPressed = HitActions.Contains(e.Action);
 
             // Only count this as handled if the new judgement is a hit
-            var result = UpdateResult(true);
+            bool result = UpdateResult(true);
             if (IsHit)
                 HitAction = e.Action;
 

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

@@ -185,9 +185,9 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
                 nextTick?.TriggerResult(true);
 
-                var numHits = ticks.Count(r => r.IsHit);
+                int numHits = ticks.Count(r => r.IsHit);
 
-                var completion = (float)numHits / HitObject.RequiredHits;
+                float completion = (float)numHits / HitObject.RequiredHits;
 
                 expandingRing
                     .FadeTo(expandingRing.Alpha + Math.Clamp(completion / 16, 0.1f, 0.6f), 50)
@@ -273,7 +273,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             if (Time.Current < HitObject.StartTime)
                 return false;
 
-            var isCentre = e.Action == TaikoAction.LeftCentre || e.Action == TaikoAction.RightCentre;
+            bool isCentre = e.Action == TaikoAction.LeftCentre || e.Action == TaikoAction.RightCentre;
 
             // Ensure alternating centre and rim hits
             if (lastWasCentre == isCentre)

osu.Game.Rulesets.Taiko/Skinning/Legacy/TaikoLegacySkinTransformer.cs

@@ -91,7 +91,7 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
 
                     case TaikoSkinComponents.TaikoExplosionOk:
                     case TaikoSkinComponents.TaikoExplosionGreat:
-                        var hitName = getHitName(taikoComponent.Component);
+                        string hitName = getHitName(taikoComponent.Component);
                         var hitSprite = this.GetAnimation(hitName, true, false);
 
                         if (hitSprite != null)
@@ -162,10 +162,10 @@ namespace osu.Game.Rulesets.Taiko.Skinning.Legacy
             {
                 get
                 {
-                    foreach (var name in base.LookupNames)
+                    foreach (string name in base.LookupNames)
                         yield return name.Insert(name.LastIndexOf('/') + 1, "taiko-");
 
-                    foreach (var name in base.LookupNames)
+                    foreach (string name in base.LookupNames)
                         yield return name;
                 }
             }

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

@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Taiko.UI
             base.Update();
 
             // Remove any auxiliary hit notes that were spawned during a drum roll but subsequently rewound.
-            for (var i = AliveInternalChildren.Count - 1; i >= 0; i--)
+            for (int i = AliveInternalChildren.Count - 1; i >= 0; i--)
             {
                 var flyingHit = (DrawableFlyingHit)AliveInternalChildren[i];
                 if (Time.Current <= flyingHit.HitObject.StartTime)

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

@@ -122,7 +122,7 @@ namespace osu.Game.Rulesets.Taiko.UI
 
                 if (skin == null) return;
 
-                foreach (var frameIndex in clear_animation_sequence)
+                foreach (int frameIndex in clear_animation_sequence)
                 {
                     var texture = getAnimationFrame(skin, TaikoMascotAnimationState.Clear, frameIndex);
 

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

@@ -775,5 +775,22 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.That(seventh.ControlPoints[4].Type == null);
             }
         }
+
+        [Test]
+        public void TestSliderLengthExtensionEdgeCase()
+        {
+            var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
+
+            using (var resStream = TestResources.OpenResource("duplicate-last-position-slider.osu"))
+            using (var stream = new LineBufferedReader(resStream))
+            {
+                var decoded = decoder.Decode(stream);
+
+                var path = ((IHasPath)decoded.HitObjects[0]).Path;
+
+                Assert.That(path.ExpectedDistance.Value, Is.EqualTo(2));
+                Assert.That(path.Distance, Is.EqualTo(1));
+            }
+        }
     }
 }

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

@@ -40,7 +40,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
             protected override bool ShouldSkipLine(string line)
             {
-                var result = base.ShouldSkipLine(line);
+                bool result = base.ShouldSkipLine(line);
 
                 if (!result)
                     ParsedLines.Add(line);

osu.Game.Tests/Beatmaps/IO/ImportBeatmapTest.cs

@@ -82,7 +82,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 {
                     var osu = LoadOsuIntoHost(host);
 
-                    var tempPath = TestResources.GetTestBeatmapForImport();
+                    string tempPath = TestResources.GetTestBeatmapForImport();
 
                     var manager = osu.Dependencies.Get<BeatmapManager>();
 
@@ -144,7 +144,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 {
                     var osu = LoadOsuIntoHost(host);
 
-                    var temp = TestResources.GetTestBeatmapForImport();
+                    string temp = TestResources.GetTestBeatmapForImport();
 
                     string extractedFolder = $"{temp}_extracted";
                     Directory.CreateDirectory(extractedFolder);
@@ -196,7 +196,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 {
                     var osu = LoadOsuIntoHost(host);
 
-                    var temp = TestResources.GetTestBeatmapForImport();
+                    string temp = TestResources.GetTestBeatmapForImport();
 
                     string extractedFolder = $"{temp}_extracted";
                     Directory.CreateDirectory(extractedFolder);
@@ -251,7 +251,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 {
                     var osu = LoadOsuIntoHost(host);
 
-                    var temp = TestResources.GetTestBeatmapForImport();
+                    string temp = TestResources.GetTestBeatmapForImport();
 
                     string extractedFolder = $"{temp}_extracted";
                     Directory.CreateDirectory(extractedFolder);
@@ -302,7 +302,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 {
                     var osu = LoadOsuIntoHost(host);
 
-                    var temp = TestResources.GetTestBeatmapForImport();
+                    string temp = TestResources.GetTestBeatmapForImport();
 
                     string extractedFolder = $"{temp}_extracted";
                     Directory.CreateDirectory(extractedFolder);
@@ -424,7 +424,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                     checkBeatmapCount(osu, 12);
                     checkSingleReferencedFileCount(osu, 18);
 
-                    var brokenTempFilename = TestResources.GetTestBeatmapForImport();
+                    string brokenTempFilename = TestResources.GetTestBeatmapForImport();
 
                     MemoryStream brokenOsu = new MemoryStream();
                     MemoryStream brokenOsz = new MemoryStream(await File.ReadAllBytesAsync(brokenTempFilename));
@@ -594,7 +594,7 @@ namespace osu.Game.Tests.Beatmaps.IO
 
                     var osu = LoadOsuIntoHost(host);
 
-                    var temp = TestResources.GetTestBeatmapForImport();
+                    string temp = TestResources.GetTestBeatmapForImport();
 
                     var importer = new ArchiveImportIPCChannel(client);
                     if (!importer.ImportAsync(temp).Wait(10000))
@@ -619,7 +619,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 try
                 {
                     var osu = LoadOsuIntoHost(host);
-                    var temp = TestResources.GetTestBeatmapForImport();
+                    string temp = TestResources.GetTestBeatmapForImport();
                     using (File.OpenRead(temp))
                         await osu.Dependencies.Get<BeatmapManager>().Import(temp);
                     ensureLoaded(osu);
@@ -642,7 +642,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 {
                     var osu = LoadOsuIntoHost(host);
 
-                    var temp = TestResources.GetTestBeatmapForImport();
+                    string temp = TestResources.GetTestBeatmapForImport();
 
                     string extractedFolder = $"{temp}_extracted";
                     Directory.CreateDirectory(extractedFolder);
@@ -684,7 +684,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 {
                     var osu = LoadOsuIntoHost(host);
 
-                    var temp = TestResources.GetTestBeatmapForImport();
+                    string temp = TestResources.GetTestBeatmapForImport();
 
                     string extractedFolder = $"{temp}_extracted";
                     string subfolder = Path.Combine(extractedFolder, "subfolder");
@@ -729,7 +729,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 {
                     var osu = LoadOsuIntoHost(host);
 
-                    var temp = TestResources.GetTestBeatmapForImport();
+                    string temp = TestResources.GetTestBeatmapForImport();
 
                     string extractedFolder = $"{temp}_extracted";
                     string dataFolder = Path.Combine(extractedFolder, "actual_data");
@@ -784,7 +784,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                     var osu = LoadOsuIntoHost(host);
                     var manager = osu.Dependencies.Get<BeatmapManager>();
 
-                    var temp = TestResources.GetTestBeatmapForImport();
+                    string temp = TestResources.GetTestBeatmapForImport();
                     await osu.Dependencies.Get<BeatmapManager>().Import(temp);
 
                     // Update via the beatmap, not the beatmap info, to ensure correct linking
@@ -814,7 +814,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                     var osu = LoadOsuIntoHost(host);
                     var manager = osu.Dependencies.Get<BeatmapManager>();
 
-                    var temp = TestResources.GetTestBeatmapForImport();
+                    string temp = TestResources.GetTestBeatmapForImport();
                     await osu.Dependencies.Get<BeatmapManager>().Import(temp);
 
                     BeatmapSetInfo setToUpdate = manager.GetAllUsableBeatmapSets()[0];
@@ -905,7 +905,7 @@ namespace osu.Game.Tests.Beatmaps.IO
 
         public static async Task<BeatmapSetInfo> LoadQuickOszIntoOsu(OsuGameBase osu)
         {
-            var temp = TestResources.GetQuickTestBeatmapForImport();
+            string temp = TestResources.GetQuickTestBeatmapForImport();
 
             var manager = osu.Dependencies.Get<BeatmapManager>();
 
@@ -920,7 +920,7 @@ namespace osu.Game.Tests.Beatmaps.IO
 
         public static async Task<BeatmapSetInfo> LoadOszIntoOsu(OsuGameBase osu, string path = null, bool virtualTrack = false)
         {
-            var temp = path ?? TestResources.GetTestBeatmapForImport(virtualTrack);
+            string temp = path ?? TestResources.GetTestBeatmapForImport(virtualTrack);
 
             var manager = osu.Dependencies.Get<BeatmapManager>();
 

osu.Game.Tests/Beatmaps/IO/LineBufferedReaderTest.cs

@@ -114,7 +114,7 @@ namespace osu.Game.Tests.Beatmaps.IO
                 Assert.AreEqual("this line is gone", bufferedReader.ReadLine());
                 Assert.AreEqual("this one shouldn't be", bufferedReader.PeekLine());
 
-                var endingLines = bufferedReader.ReadToEnd().Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
+                string[] endingLines = bufferedReader.ReadToEnd().Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
                 Assert.AreEqual(3, endingLines.Length);
                 Assert.AreEqual("this one shouldn't be", endingLines[0]);
                 Assert.AreEqual("these ones", endingLines[1]);

osu.Game.Tests/Beatmaps/IO/OszArchiveReaderTest.cs

@@ -36,8 +36,8 @@ namespace osu.Game.Tests.Beatmaps.IO
                     "Soleily - Renatus (MMzz) [Muzukashii].osu",
                     "Soleily - Renatus (MMzz) [Oni].osu"
                 };
-                var maps = reader.Filenames.ToArray();
+                string[] maps = reader.Filenames.ToArray();
-                foreach (var map in expected)
+                foreach (string map in expected)
                     Assert.Contains(map, maps);
             }
         }
@@ -77,8 +77,7 @@ namespace osu.Game.Tests.Beatmaps.IO
             {
                 var reader = new ZipArchiveReader(osz);
 
-                using (var stream = new StreamReader(
+                using (var stream = new StreamReader(reader.GetStream("Soleily - Renatus (Deif) [Platter].osu")))
-                    reader.GetStream("Soleily - Renatus (Deif) [Platter].osu")))
                 {
                     Assert.AreEqual("osu file format v13", stream.ReadLine()?.Trim());
                 }

osu.Game.Tests/Database/BeatmapImporterTests.cs

@@ -94,7 +94,7 @@ namespace osu.Game.Tests.Database
                 using var importer = new BeatmapImporter(realmFactory, storage);
                 using var store = new RealmRulesetStore(realmFactory, storage);
 
-                var tempPath = TestResources.GetTestBeatmapForImport();
+                string? tempPath = TestResources.GetTestBeatmapForImport();
 
                 ILive<RealmBeatmapSet>? importedSet;
 
@@ -144,7 +144,7 @@ namespace osu.Game.Tests.Database
                 using var importer = new BeatmapImporter(realmFactory, storage);
                 using var store = new RealmRulesetStore(realmFactory, storage);
 
-                var temp = TestResources.GetTestBeatmapForImport();
+                string? temp = TestResources.GetTestBeatmapForImport();
 
                 string extractedFolder = $"{temp}_extracted";
                 Directory.CreateDirectory(extractedFolder);
@@ -193,7 +193,7 @@ namespace osu.Game.Tests.Database
                 using var importer = new BeatmapImporter(realmFactory, storage);
                 using var store = new RealmRulesetStore(realmFactory, storage);
 
-                var temp = TestResources.GetTestBeatmapForImport();
+                string? temp = TestResources.GetTestBeatmapForImport();
 
                 string extractedFolder = $"{temp}_extracted";
                 Directory.CreateDirectory(extractedFolder);
@@ -245,7 +245,7 @@ namespace osu.Game.Tests.Database
                 using var importer = new BeatmapImporter(realmFactory, storage);
                 using var store = new RealmRulesetStore(realmFactory, storage);
 
-                var temp = TestResources.GetTestBeatmapForImport();
+                string? temp = TestResources.GetTestBeatmapForImport();
 
                 string extractedFolder = $"{temp}_extracted";
                 Directory.CreateDirectory(extractedFolder);
@@ -293,7 +293,7 @@ namespace osu.Game.Tests.Database
                 using var importer = new BeatmapImporter(realmFactory, storage);
                 using var store = new RealmRulesetStore(realmFactory, storage);
 
-                var temp = TestResources.GetTestBeatmapForImport();
+                string? temp = TestResources.GetTestBeatmapForImport();
 
                 string extractedFolder = $"{temp}_extracted";
                 Directory.CreateDirectory(extractedFolder);
@@ -391,7 +391,7 @@ namespace osu.Game.Tests.Database
                 checkBeatmapCount(realmFactory.Context, 12);
                 checkSingleReferencedFileCount(realmFactory.Context, 18);
 
-                var brokenTempFilename = TestResources.GetTestBeatmapForImport();
+                string? brokenTempFilename = TestResources.GetTestBeatmapForImport();
 
                 MemoryStream brokenOsu = new MemoryStream();
                 MemoryStream brokenOsz = new MemoryStream(await File.ReadAllBytesAsync(brokenTempFilename));
@@ -522,7 +522,7 @@ namespace osu.Game.Tests.Database
                 using var importer = new BeatmapImporter(realmFactory, storage);
                 using var store = new RealmRulesetStore(realmFactory, storage);
 
-                var temp = TestResources.GetTestBeatmapForImport();
+                string? temp = TestResources.GetTestBeatmapForImport();
                 using (File.OpenRead(temp))
                     await importer.Import(temp);
                 ensureLoaded(realmFactory.Context);
@@ -539,7 +539,7 @@ namespace osu.Game.Tests.Database
                 using var importer = new BeatmapImporter(realmFactory, storage);
                 using var store = new RealmRulesetStore(realmFactory, storage);
 
-                var temp = TestResources.GetTestBeatmapForImport();
+                string? temp = TestResources.GetTestBeatmapForImport();
 
                 string extractedFolder = $"{temp}_extracted";
                 Directory.CreateDirectory(extractedFolder);
@@ -575,7 +575,7 @@ namespace osu.Game.Tests.Database
                 using var importer = new BeatmapImporter(realmFactory, storage);
                 using var store = new RealmRulesetStore(realmFactory, storage);
 
-                var temp = TestResources.GetTestBeatmapForImport();
+                string? temp = TestResources.GetTestBeatmapForImport();
 
                 string extractedFolder = $"{temp}_extracted";
                 string subfolder = Path.Combine(extractedFolder, "subfolder");
@@ -617,7 +617,7 @@ namespace osu.Game.Tests.Database
                 using var importer = new BeatmapImporter(realmFactory, storage);
                 using var store = new RealmRulesetStore(realmFactory, storage);
 
-                var temp = TestResources.GetTestBeatmapForImport();
+                string? temp = TestResources.GetTestBeatmapForImport();
 
                 string extractedFolder = $"{temp}_extracted";
                 string dataFolder = Path.Combine(extractedFolder, "actual_data");
@@ -668,7 +668,7 @@ namespace osu.Game.Tests.Database
                 using var importer = new BeatmapImporter(realmFactory, storage);
                 using var store = new RealmRulesetStore(realmFactory, storage);
 
-                var temp = TestResources.GetTestBeatmapForImport();
+                string? temp = TestResources.GetTestBeatmapForImport();
                 await importer.Import(temp);
 
                 // Update via the beatmap, not the beatmap info, to ensure correct linking
@@ -685,7 +685,7 @@ namespace osu.Game.Tests.Database
 
         public static async Task<RealmBeatmapSet?> LoadQuickOszIntoOsu(BeatmapImporter importer, Realm realm)
         {
-            var temp = TestResources.GetQuickTestBeatmapForImport();
+            string? temp = TestResources.GetQuickTestBeatmapForImport();
 
             var importedSet = await importer.Import(new ImportTask(temp));
 
@@ -700,7 +700,7 @@ namespace osu.Game.Tests.Database
 
         public static async Task<RealmBeatmapSet> LoadOszIntoStore(BeatmapImporter importer, Realm realm, string? path = null, bool virtualTrack = false)
         {
-            var temp = path ?? TestResources.GetTestBeatmapForImport(virtualTrack);
+            string? temp = path ?? TestResources.GetTestBeatmapForImport(virtualTrack);
 
             var importedSet = await importer.Import(new ImportTask(temp));
 

osu.Game.Tests/NonVisual/BarLineGeneratorTest.cs

@@ -49,7 +49,7 @@ namespace osu.Game.Tests.NonVisual
             for (int i = 0; i * beat_length_denominator < barLines.Count; i++)
             {
                 var barLine = barLines[i * beat_length_denominator];
-                var expectedTime = beat_length_numerator * (int)signature * i;
+                int expectedTime = beat_length_numerator * (int)signature * i;
 
                 // every seventh bar's start time should be at least greater than the whole number we expect.
                 // It cannot be less, as that can affect overlapping scroll algorithms

osu.Game.Tests/NonVisual/CustomDataDirectoryTest.cs

@@ -87,7 +87,7 @@ namespace osu.Game.Tests.NonVisual
                     File.WriteAllText(actualTestFile, "test");
 
                     var rulesetStorage = storage.GetStorageForDirectory("rulesets");
-                    var lookupPath = rulesetStorage.GetFiles(".").Single();
+                    string lookupPath = rulesetStorage.GetFiles(".").Single();
 
                     Assert.That(lookupPath, Is.EqualTo("test"));
                 }
@@ -140,7 +140,7 @@ namespace osu.Game.Tests.NonVisual
 
                     Assert.That(osuStorage, Is.Not.Null);
 
-                    foreach (var file in osuStorage.IgnoreFiles)
+                    foreach (string file in osuStorage.IgnoreFiles)
                     {
                         // avoid touching realm files which may be a pipe and break everything.
                         // this is also done locally inside OsuStorage via the IgnoreFiles list.
@@ -149,7 +149,7 @@ namespace osu.Game.Tests.NonVisual
                         Assert.That(storage.Exists(file), Is.False);
                     }
 
-                    foreach (var dir in osuStorage.IgnoreDirectories)
+                    foreach (string dir in osuStorage.IgnoreDirectories)
                     {
                         Assert.That(Directory.Exists(Path.Combine(originalDirectory, dir)));
                         Assert.That(storage.ExistsDirectory(dir), Is.False);

osu.Game.Tests/NonVisual/FramedReplayInputHandlerTest.cs

@@ -347,7 +347,7 @@ namespace osu.Game.Tests.NonVisual
         {
             for (int i = 0; i < 1000; i++)
             {
-                var time = handler.SetFrameFromTime(destination);
+                double? time = handler.SetFrameFromTime(destination);
                 if (time == null || time == destination)
                     return;
             }

osu.Game.Tests/NonVisual/LimitedCapacityQueueTest.cs

@@ -30,7 +30,7 @@ namespace osu.Game.Tests.NonVisual
             Assert.Throws<InvalidOperationException>(() => _ = queue.Dequeue());
 
             int count = 0;
-            foreach (var _ in queue)
+            foreach (int _ in queue)
                 count++;
 
             Assert.AreEqual(0, count);
@@ -50,7 +50,7 @@ namespace osu.Game.Tests.NonVisual
                 Assert.AreEqual(i, queue[i]);
 
             int j = 0;
-            foreach (var item in queue)
+            foreach (int item in queue)
                 Assert.AreEqual(j++, item);
 
             for (int i = queue.Count; i < queue.Count + capacity; i++)
@@ -71,7 +71,7 @@ namespace osu.Game.Tests.NonVisual
                 Assert.AreEqual(count - capacity + i, queue[i]);
 
             int j = count - capacity;
-            foreach (var item in queue)
+            foreach (int item in queue)
                 Assert.AreEqual(j++, item);
 
             for (int i = queue.Count; i < queue.Count + capacity; i++)

osu.Game.Tests/NonVisual/Multiplayer/StatefulMultiplayerClientTest.cs

@@ -84,7 +84,7 @@ namespace osu.Game.Tests.NonVisual.Multiplayer
             {
                 for (int i = 0; i < userCount; ++i)
                 {
-                    var userId = Client.Room?.Users[i].UserID ?? throw new AssertionException("Room cannot be null!");
+                    int userId = Client.Room?.Users[i].UserID ?? throw new AssertionException("Room cannot be null!");
                     Client.ChangeUserState(userId, state);
                 }
             });

osu.Game.Tests/NonVisual/ReverseQueueTest.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Tests.NonVisual
             });
 
             int count = 0;
-            foreach (var unused in queue)
+            foreach (char unused in queue)
                 count++;
 
             Assert.AreEqual(0, count);
@@ -72,7 +72,7 @@ namespace osu.Game.Tests.NonVisual
 
             // Assert correct item return and no longer in queue after dequeueing
             Assert.AreEqual('a', queue[5]);
-            var dequeuedItem = queue.Dequeue();
+            char dequeuedItem = queue.Dequeue();
 
             Assert.AreEqual('a', dequeuedItem);
             Assert.AreEqual(5, queue.Count);
@@ -133,7 +133,7 @@ namespace osu.Game.Tests.NonVisual
             int expectedValueIndex = 0;
 
             // Assert items are enumerated in correct order
-            foreach (var item in queue)
+            foreach (char item in queue)
             {
                 Assert.AreEqual(expectedValues[expectedValueIndex], item);
                 expectedValueIndex++;

osu.Game.Tests/Online/TestMultiplayerMessagePackSerialization.cs

@@ -20,7 +20,7 @@ namespace osu.Game.Tests.Online
                 MatchState = new TeamVersusRoomState()
             };
 
-            var serialized = MessagePackSerializer.Serialize(room);
+            byte[] serialized = MessagePackSerializer.Serialize(room);
 
             var deserialized = MessagePackSerializer.Deserialize<MultiplayerRoom>(serialized);
 
@@ -32,7 +32,7 @@ namespace osu.Game.Tests.Online
         {
             var state = new TeamVersusUserState();
 
-            var serialized = MessagePackSerializer.Serialize(typeof(MatchUserState), state);
+            byte[] serialized = MessagePackSerializer.Serialize(typeof(MatchUserState), state);
             var deserialized = MessagePackSerializer.Deserialize<MatchUserState>(serialized);
 
             Assert.IsTrue(deserialized is TeamVersusUserState);
@@ -44,7 +44,7 @@ namespace osu.Game.Tests.Online
             var state = new TeamVersusUserState();
 
             // SignalR serialises using the actual type, rather than a base specification.
-            var serialized = MessagePackSerializer.Serialize(typeof(TeamVersusUserState), state);
+            byte[] serialized = MessagePackSerializer.Serialize(typeof(TeamVersusUserState), state);
 
             // works with explicit type specified.
             MessagePackSerializer.Deserialize<TeamVersusUserState>(serialized);
@@ -59,7 +59,7 @@ namespace osu.Game.Tests.Online
             var state = new TeamVersusUserState();
 
             // SignalR serialises using the actual type, rather than a base specification.
-            var serialized = MessagePackSerializer.Serialize(typeof(TeamVersusUserState), state, SignalRUnionWorkaroundResolver.OPTIONS);
+            byte[] serialized = MessagePackSerializer.Serialize(typeof(TeamVersusUserState), state, SignalRUnionWorkaroundResolver.OPTIONS);
 
             // works with explicit type specified.
             MessagePackSerializer.Deserialize<TeamVersusUserState>(serialized);

osu.Game.Tests/Resources/TestResources.cs

@@ -29,7 +29,7 @@ namespace osu.Game.Tests.Resources
         /// <returns>A path to a copy of a beatmap archive (osz). Should be deleted after use.</returns>
         public static string GetQuickTestBeatmapForImport()
         {
-            var tempPath = getTempFilename();
+            string tempPath = getTempFilename();
             using (var stream = OpenResource("Archives/241526 Soleily - Renatus_virtual_quick.osz"))
             using (var newFile = File.Create(tempPath))
                 stream.CopyTo(newFile);
@@ -45,7 +45,7 @@ namespace osu.Game.Tests.Resources
         /// <returns>A path to a copy of a beatmap archive (osz). Should be deleted after use.</returns>
         public static string GetTestBeatmapForImport(bool virtualTrack = false)
         {
-            var tempPath = getTempFilename();
+            string tempPath = getTempFilename();
 
             using (var stream = GetTestBeatmapStream(virtualTrack))
             using (var newFile = File.Create(tempPath))

osu.Game.Tests/Resources/duplicate-last-position-slider.osu

@@ -0,0 +1,19 @@
+osu file format v14
+
+[Difficulty]
+HPDrainRate:7
+CircleSize:10
+OverallDifficulty:9
+ApproachRate:10
+SliderMultiplier:0.4
+SliderTickRate:1
+
+[TimingPoints]
+382,923.076923076923,3,2,1,75,1,0
+382,-1000,3,2,1,75,0,0
+
+[HitObjects]
+
+// Importantly, the last position is specified twice.
+// In this case, osu-stable doesn't extend the slider length even when the "expected" length is higher than the actual.
+261,171,25305,6,0,B|262:171|262:171|262:171,1,2,8|0,0:0|0:0,0:0:0:0:

osu.Game.Tests/Visual/Beatmaps/TestSceneBeatmapSetOnlineStatusPill.cs

@@ -0,0 +1,53 @@
+// 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 NUnit.Framework;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Overlays;
+using osu.Game.Tests.Visual.UserInterface;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Beatmaps
+{
+    public class TestSceneBeatmapSetOnlineStatusPill : ThemeComparisonTestScene
+    {
+        protected override Drawable CreateContent() => new FillFlowContainer
+        {
+            AutoSizeAxes = Axes.Both,
+            Anchor = Anchor.Centre,
+            Origin = Anchor.Centre,
+            Direction = FillDirection.Vertical,
+            Spacing = new Vector2(0, 10),
+            ChildrenEnumerable = Enum.GetValues(typeof(BeatmapSetOnlineStatus)).Cast<BeatmapSetOnlineStatus>().Select(status => new BeatmapSetOnlineStatusPill
+            {
+                AutoSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Status = status
+            })
+        };
+
+        private IEnumerable<BeatmapSetOnlineStatusPill> statusPills => this.ChildrenOfType<BeatmapSetOnlineStatusPill>();
+
+        [Test]
+        public void TestFixedWidth()
+        {
+            AddStep("create themed content", () => CreateThemedContent(OverlayColourScheme.Red));
+
+            AddStep("set fixed width", () => statusPills.ForEach(pill =>
+            {
+                pill.AutoSizeAxes = Axes.Y;
+                pill.Width = 90;
+            }));
+            AddStep("unset fixed width", () => statusPills.ForEach(pill => pill.AutoSizeAxes = Axes.Both));
+        }
+    }
+}

osu.Game.Tests/Visual/Beatmaps/TestSceneDifficultySpectrumDisplay.cs

@@ -0,0 +1,110 @@
+// 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 NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Drawables;
+using osu.Game.Online.API.Requests.Responses;
+using osuTK;
+
+namespace osu.Game.Tests.Visual.Beatmaps
+{
+    public class TestSceneDifficultySpectrumDisplay : OsuTestScene
+    {
+        private DifficultySpectrumDisplay display;
+
+        private static APIBeatmapSet createBeatmapSetWith(params (int rulesetId, double stars)[] difficulties) => new APIBeatmapSet
+        {
+            Beatmaps = difficulties.Select(difficulty => new APIBeatmap
+            {
+                RulesetID = difficulty.rulesetId,
+                StarRating = difficulty.stars
+            }).ToList()
+        };
+
+        [Test]
+        public void TestSingleRuleset()
+        {
+            var beatmapSet = createBeatmapSetWith(
+                (rulesetId: 0, stars: 2.0),
+                (rulesetId: 0, stars: 3.2),
+                (rulesetId: 0, stars: 5.6));
+
+            createDisplay(beatmapSet);
+        }
+
+        [Test]
+        public void TestMultipleRulesets()
+        {
+            var beatmapSet = createBeatmapSetWith(
+                (rulesetId: 0, stars: 2.0),
+                (rulesetId: 3, stars: 2.3),
+                (rulesetId: 0, stars: 3.2),
+                (rulesetId: 1, stars: 4.3),
+                (rulesetId: 0, stars: 5.6));
+
+            createDisplay(beatmapSet);
+        }
+
+        [Test]
+        public void TestUnknownRuleset()
+        {
+            var beatmapSet = createBeatmapSetWith(
+                (rulesetId: 0, stars: 2.0),
+                (rulesetId: 3, stars: 2.3),
+                (rulesetId: 0, stars: 3.2),
+                (rulesetId: 1, stars: 4.3),
+                (rulesetId: 0, stars: 5.6),
+                (rulesetId: 15, stars: 7.8));
+
+            createDisplay(beatmapSet);
+        }
+
+        [Test]
+        public void TestMaximumUncollapsed()
+        {
+            var beatmapSet = createBeatmapSetWith(Enumerable.Range(0, 12).Select(i => (rulesetId: i % 4, stars: 2.5 + i * 0.25)).ToArray());
+            createDisplay(beatmapSet);
+        }
+
+        [Test]
+        public void TestMinimumCollapsed()
+        {
+            var beatmapSet = createBeatmapSetWith(Enumerable.Range(0, 13).Select(i => (rulesetId: i % 4, stars: 2.5 + i * 0.25)).ToArray());
+            createDisplay(beatmapSet);
+        }
+
+        [Test]
+        public void TestAdjustableDotSize()
+        {
+            var beatmapSet = createBeatmapSetWith(
+                (rulesetId: 0, stars: 2.0),
+                (rulesetId: 3, stars: 2.3),
+                (rulesetId: 0, stars: 3.2),
+                (rulesetId: 1, stars: 4.3),
+                (rulesetId: 0, stars: 5.6));
+
+            createDisplay(beatmapSet);
+
+            AddStep("change dot dimensions", () =>
+            {
+                display.DotSize = new Vector2(8, 12);
+                display.DotSpacing = 2;
+            });
+            AddStep("change dot dimensions back", () =>
+            {
+                display.DotSize = new Vector2(4, 8);
+                display.DotSpacing = 1;
+            });
+        }
+
+        private void createDisplay(IBeatmapSetInfo beatmapSetInfo) => AddStep("create spectrum display", () => Child = display = new DifficultySpectrumDisplay(beatmapSetInfo)
+        {
+            Anchor = Anchor.Centre,
+            Origin = Anchor.Centre,
+            Scale = new Vector2(3)
+        });
+    }
+}

osu.Game.Tests/Visual/Components/TestScenePreviewTrackManager.cs

@@ -224,7 +224,7 @@ namespace osu.Game.Tests.Visual.Components
 
             public new PreviewTrack CurrentTrack => base.CurrentTrack;
 
-            protected override TrackManagerPreviewTrack CreatePreviewTrack(BeatmapSetInfo beatmapSetInfo, ITrackStore trackStore) => new TestPreviewTrack(beatmapSetInfo, trackStore);
+            protected override TrackManagerPreviewTrack CreatePreviewTrack(IBeatmapSetInfo beatmapSetInfo, ITrackStore trackStore) => new TestPreviewTrack(beatmapSetInfo, trackStore);
 
             public override bool UpdateSubTree()
             {
@@ -240,7 +240,7 @@ namespace osu.Game.Tests.Visual.Components
 
                 public new Track Track => base.Track;
 
-                public TestPreviewTrack(BeatmapSetInfo beatmapSetInfo, ITrackStore trackManager)
+                public TestPreviewTrack(IBeatmapSetInfo beatmapSetInfo, ITrackStore trackManager)
                     : base(beatmapSetInfo, trackManager)
                 {
                     this.trackManager = trackManager;

osu.Game.Tests/Visual/Editing/TestSceneBeatDivisorControl.cs

@@ -72,7 +72,7 @@ namespace osu.Game.Tests.Visual.Editing
 
         private Vector2 getPositionForDivisor(int divisor)
         {
-            var relativePosition = (float)Math.Clamp(divisor, 0, 16) / 16;
+            float relativePosition = (float)Math.Clamp(divisor, 0, 16) / 16;
             var sliderDrawQuad = tickSliderBar.ScreenSpaceDrawQuad;
             return new Vector2(
                 sliderDrawQuad.TopLeft.X + sliderDrawQuad.Width * relativePosition,

osu.Game.Tests/Visual/Editing/TestSceneEditorBeatmapCreation.cs

@@ -76,7 +76,7 @@ namespace osu.Game.Tests.Visual.Editing
             {
                 var setup = Editor.ChildrenOfType<SetupScreen>().First();
 
-                var temp = TestResources.GetTestBeatmapForImport();
+                string temp = TestResources.GetTestBeatmapForImport();
 
                 string extractedFolder = $"{temp}_extracted";
                 Directory.CreateDirectory(extractedFolder);

osu.Game.Tests/Visual/Editing/TestSceneEditorSaving.cs

@@ -56,6 +56,11 @@ namespace osu.Game.Tests.Visual.Editing
 
             checkMutations();
 
+            // After placement these must be non-default as defaults are read-only.
+            AddAssert("Placed object has non-default control points", () =>
+                editorBeatmap.HitObjects[0].SampleControlPoint != SampleControlPoint.DEFAULT &&
+                editorBeatmap.HitObjects[0].DifficultyControlPoint != DifficultyControlPoint.DEFAULT);
+
             AddStep("Save", () => InputManager.Keys(PlatformAction.Save));
 
             checkMutations();

osu.Game.Tests/Visual/Gameplay/TestSceneGameplayMenuOverlay.cs

@@ -57,7 +57,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             showOverlay();
 
-            var retryCount = 0;
+            int retryCount = 0;
 
             AddRepeatStep("Add retry", () =>
             {

osu.Game.Tests/Visual/Multiplayer/TestSceneGameplayChatDisplay.cs

@@ -92,6 +92,18 @@ namespace osu.Game.Tests.Visual.Multiplayer
             assertChatFocused(true);
         }
 
+        [Test]
+        public void TestFocusLostOnBackKey()
+        {
+            setLocalUserPlaying(true);
+
+            assertChatFocused(false);
+            AddStep("press tab", () => InputManager.Key(Key.Tab));
+            assertChatFocused(true);
+            AddStep("press escape", () => InputManager.Key(Key.Escape));
+            assertChatFocused(false);
+        }
+
         [Test]
         public void TestFocusOnTabKeyWhenNotExpanded()
         {

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorLeaderboard.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                     { PLAYER_2_ID, new ManualClock() }
                 };
 
-                foreach (var (userId, _) in clocks)
+                foreach ((int userId, var _) in clocks)
                 {
                     SpectatorClient.StartPlay(userId, 0);
                     OnlinePlayDependencies.Client.AddUser(new User { Id = userId });
@@ -53,7 +53,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("add clock sources", () =>
             {
-                foreach (var (userId, clock) in clocks)
+                foreach ((int userId, var clock) in clocks)
                     leaderboard.AddClock(userId, clock);
             });
         }

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs

@@ -289,7 +289,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestSpectatingDuringGameplay()
         {
-            var players = new[] { PLAYER_1_ID, PLAYER_2_ID };
+            int[] players = { PLAYER_1_ID, PLAYER_2_ID };
 
             start(players);
             sendFrames(players, 300);
@@ -326,7 +326,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             for (int count = 3; count >= 0; count--)
             {
-                var id = PLAYER_1_ID + count;
+                int id = PLAYER_1_ID + count;
 
                 end(id);
                 AddUntilStep($"{id} area grayed", () => getInstance(id).Colour != Color4.White);

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs

@@ -582,7 +582,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
             // Gameplay runs in real-time, so we need to incrementally check if gameplay has finished in order to not time out.
             for (double i = 1000; i < TestResources.QUICK_BEATMAP_LENGTH; i += 1000)
             {
-                var time = i;
+                double time = i;
                 AddUntilStep($"wait for time > {i}", () => this.ChildrenOfType<GameplayClockContainer>().SingleOrDefault()?.GameplayClock.CurrentTime > time);
             }
 

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboard.cs

@@ -55,7 +55,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 var playableBeatmap = Beatmap.Value.GetPlayableBeatmap(Ruleset.Value);
                 var multiplayerUsers = new List<MultiplayerRoomUser>();
 
-                foreach (var user in users)
+                foreach (int user in users)
                 {
                     SpectatorClient.StartPlay(user, Beatmap.Value.BeatmapInfo.OnlineBeatmapID ?? 0);
                     multiplayerUsers.Add(OnlinePlayDependencies.Client.AddUser(new User { Id = user }, true));
@@ -89,7 +89,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
         [Test]
         public void TestUserQuit()
         {
-            foreach (var user in users)
+            foreach (int user in users)
                 AddStep($"mark user {user} quit", () => Client.RemoveUser(LookupCache.GetUserAsync(user).Result.AsNonNull()));
         }
 
@@ -114,7 +114,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             public void RandomlyUpdateState()
             {
-                foreach (var userId in PlayingUsers)
+                foreach (int userId in PlayingUsers)
                 {
                     if (RNG.NextBool())
                         continue;

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerGameplayLeaderboardTeams.cs

@@ -59,7 +59,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
                 var playableBeatmap = Beatmap.Value.GetPlayableBeatmap(Ruleset.Value);
                 var multiplayerUsers = new List<MultiplayerRoomUser>();
 
-                foreach (var user in users)
+                foreach (int user in users)
                 {
                     SpectatorClient.StartPlay(user, Beatmap.Value.BeatmapInfo.OnlineBeatmapID ?? 0);
                     var roomUser = OnlinePlayDependencies.Client.AddUser(new User { Id = user }, true);

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayerParticipantsList.cs

@@ -112,7 +112,7 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddRepeatStep("increment progress", () =>
             {
-                var progress = this.ChildrenOfType<ParticipantPanel>().Single().User.BeatmapAvailability.DownloadProgress ?? 0;
+                float progress = this.ChildrenOfType<ParticipantPanel>().Single().User.BeatmapAvailability.DownloadProgress ?? 0;
                 Client.ChangeBeatmapAvailability(BeatmapAvailability.Downloading(progress + RNG.NextSingle(0.1f)));
             }, 25);
 

osu.Game.Tests/Visual/Online/TestSceneBeatmapListingOverlay.cs

@@ -7,14 +7,12 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Testing;
-using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.BeatmapListing;
-using osu.Game.Rulesets;
 using osu.Game.Scoring;
 using osu.Game.Users;
 using osuTK.Input;
@@ -92,7 +90,7 @@ namespace osu.Game.Tests.Visual.Online
         {
             AddAssert("is visible", () => overlay.State.Value == Visibility.Visible);
 
-            AddStep("show many results", () => fetchFor(Enumerable.Repeat(CreateBeatmap(Ruleset.Value).BeatmapInfo.BeatmapSet, 100).ToArray()));
+            AddStep("show many results", () => fetchFor(Enumerable.Repeat(CreateAPIBeatmapSet(Ruleset.Value), 100).ToArray()));
 
             AddUntilStep("placeholder hidden", () => !overlay.ChildrenOfType<BeatmapListingOverlay.NotFoundDrawable>().Any(d => d.IsPresent));
 
@@ -114,7 +112,7 @@ namespace osu.Game.Tests.Visual.Online
             AddStep("fetch for 0 beatmaps", () => fetchFor());
             AddUntilStep("placeholder shown", () => overlay.ChildrenOfType<BeatmapListingOverlay.NotFoundDrawable>().SingleOrDefault()?.IsPresent == true);
 
-            AddStep("fetch for 1 beatmap", () => fetchFor(CreateBeatmap(Ruleset.Value).BeatmapInfo.BeatmapSet));
+            AddStep("fetch for 1 beatmap", () => fetchFor(CreateAPIBeatmapSet(Ruleset.Value)));
             AddUntilStep("placeholder hidden", () => !overlay.ChildrenOfType<BeatmapListingOverlay.NotFoundDrawable>().Any(d => d.IsPresent));
 
             AddStep("fetch for 0 beatmaps", () => fetchFor());
@@ -188,7 +186,7 @@ namespace osu.Game.Tests.Visual.Online
         [Test]
         public void TestUserWithoutSupporterUsesSupporterOnlyFiltersWithResults()
         {
-            AddStep("fetch for 1 beatmap", () => fetchFor(CreateBeatmap(Ruleset.Value).BeatmapInfo.BeatmapSet));
+            AddStep("fetch for 1 beatmap", () => fetchFor(CreateAPIBeatmapSet(Ruleset.Value)));
             AddStep("set dummy as non-supporter", () => ((DummyAPIAccess)API).LocalUser.Value.IsSupporter = false);
 
             // only Rank Achieved filter
@@ -218,7 +216,7 @@ namespace osu.Game.Tests.Visual.Online
         [Test]
         public void TestUserWithSupporterUsesSupporterOnlyFiltersWithResults()
         {
-            AddStep("fetch for 1 beatmap", () => fetchFor(CreateBeatmap(Ruleset.Value).BeatmapInfo.BeatmapSet));
+            AddStep("fetch for 1 beatmap", () => fetchFor(CreateAPIBeatmapSet(Ruleset.Value)));
             AddStep("set dummy as supporter", () => ((DummyAPIAccess)API).LocalUser.Value.IsSupporter = true);
 
             // only Rank Achieved filter
@@ -247,10 +245,10 @@ namespace osu.Game.Tests.Visual.Online
 
         private static int searchCount;
 
-        private void fetchFor(params BeatmapSetInfo[] beatmaps)
+        private void fetchFor(params APIBeatmapSet[] beatmaps)
         {
             setsForResponse.Clear();
-            setsForResponse.AddRange(beatmaps.Select(b => new TestAPIBeatmapSet(b)));
+            setsForResponse.AddRange(beatmaps);
 
             // trigger arbitrary change for fetching.
             searchControl.Query.Value = $"search {searchCount++}";
@@ -286,17 +284,5 @@ namespace osu.Game.Tests.Visual.Online
                 !overlay.ChildrenOfType<BeatmapListingOverlay.SupporterRequiredDrawable>().Any(d => d.IsPresent)
                 && !overlay.ChildrenOfType<BeatmapListingOverlay.NotFoundDrawable>().Any(d => d.IsPresent));
         }
-
-        private class TestAPIBeatmapSet : APIBeatmapSet
-        {
-            private readonly BeatmapSetInfo beatmapSet;
-
-            public TestAPIBeatmapSet(BeatmapSetInfo beatmapSet)
-            {
-                this.beatmapSet = beatmapSet;
-            }
-
-            public override BeatmapSetInfo ToBeatmapSet(RulesetStore rulesets) => beatmapSet;
-        }
     }
 }

osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlay.cs

@@ -73,10 +73,10 @@ namespace osu.Game.Tests.Visual.Online
                         Ranked = DateTime.Now,
                         BPM = 111,
                         HasVideo = true,
+                        Ratings = Enumerable.Range(0, 11).ToArray(),
                         HasStoryboard = true,
                         Covers = new BeatmapSetOnlineCovers(),
                     },
-                    Metrics = new BeatmapSetMetrics { Ratings = Enumerable.Range(0, 11).ToArray() },
                     Beatmaps = new List<BeatmapInfo>
                     {
                         new BeatmapInfo
@@ -92,20 +92,20 @@ namespace osu.Game.Tests.Visual.Online
                                 OverallDifficulty = 4.5f,
                                 ApproachRate = 6,
                             },
-                            OnlineInfo = new BeatmapOnlineInfo
+                            OnlineInfo = new APIBeatmap
                             {
                                 CircleCount = 111,
                                 SliderCount = 12,
                                 PlayCount = 222,
                                 PassCount = 21,
-                            },
+                                FailTimes = new APIFailTimes
-                            Metrics = new BeatmapMetrics
                                 {
                                     Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6).ToArray(),
                                     Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6).ToArray(),
                                 },
                             },
                         },
+                    },
                 });
             });
 
@@ -153,8 +153,8 @@ namespace osu.Game.Tests.Visual.Online
                         Covers = new BeatmapSetOnlineCovers(),
                         Language = new BeatmapSetOnlineLanguage { Id = 3, Name = "English" },
                         Genre = new BeatmapSetOnlineGenre { Id = 4, Name = "Rock" },
+                        Ratings = Enumerable.Range(0, 11).ToArray(),
                     },
-                    Metrics = new BeatmapSetMetrics { Ratings = Enumerable.Range(0, 11).ToArray() },
                     Beatmaps = new List<BeatmapInfo>
                     {
                         new BeatmapInfo
@@ -170,20 +170,20 @@ namespace osu.Game.Tests.Visual.Online
                                 OverallDifficulty = 7,
                                 ApproachRate = 6,
                             },
-                            OnlineInfo = new BeatmapOnlineInfo
+                            OnlineInfo = new APIBeatmap
                             {
                                 CircleCount = 123,
                                 SliderCount = 45,
                                 PlayCount = 567,
                                 PassCount = 89,
-                            },
+                                FailTimes = new APIFailTimes
-                            Metrics = new BeatmapMetrics
                                 {
                                     Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6).ToArray(),
                                     Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6).ToArray(),
                                 },
                             },
                         },
+                    },
                 });
             });
 
@@ -204,12 +204,14 @@ namespace osu.Game.Tests.Visual.Online
                         Version = ruleset.Name,
                         Ruleset = ruleset,
                         BaseDifficulty = new BeatmapDifficulty(),
-                        OnlineInfo = new BeatmapOnlineInfo(),
+                        OnlineInfo = new APIBeatmap
-                        Metrics = new BeatmapMetrics
+                        {
+                            FailTimes = new APIFailTimes
                             {
                                 Fails = Enumerable.Range(1, 100).Select(i => i % 12 - 6).ToArray(),
                                 Retries = Enumerable.Range(-2, 100).Select(i => i % 12 - 6).ToArray(),
                             },
+                        }
                     });
                 }
 
@@ -228,8 +230,8 @@ namespace osu.Game.Tests.Visual.Online
                     OnlineInfo = new APIBeatmapSet
                     {
                         Covers = new BeatmapSetOnlineCovers(),
+                        Ratings = Enumerable.Range(0, 11).ToArray(),
                     },
-                    Metrics = new BeatmapSetMetrics { Ratings = Enumerable.Range(0, 11).ToArray() },
                     Beatmaps = beatmaps
                 });
             });
@@ -288,12 +290,14 @@ namespace osu.Game.Tests.Visual.Online
                     {
                         OverallDifficulty = 3.5f,
                     },
-                    OnlineInfo = new BeatmapOnlineInfo(),
+                    OnlineInfo = new APIBeatmap
-                    Metrics = new BeatmapMetrics
+                    {
+                        FailTimes = new APIFailTimes
                         {
                             Fails = Enumerable.Range(1, 100).Select(j => j % 12 - 6).ToArray(),
                             Retries = Enumerable.Range(-2, 100).Select(j => j % 12 - 6).ToArray(),
                         },
+                    }
                 });
             }
 
@@ -316,8 +320,8 @@ namespace osu.Game.Tests.Visual.Online
                     HasVideo = true,
                     HasStoryboard = true,
                     Covers = new BeatmapSetOnlineCovers(),
+                    Ratings = Enumerable.Range(0, 11).ToArray(),
                 },
-                Metrics = new BeatmapSetMetrics { Ratings = Enumerable.Range(0, 11).ToArray() },
                 Beatmaps = beatmaps,
             };
         }

osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlayDetails.cs

@@ -39,27 +39,30 @@ namespace osu.Game.Tests.Visual.Online
             var secondSet = createSet();
 
             AddStep("set first set", () => details.BeatmapSet = firstSet);
-            AddAssert("ratings set", () => details.Ratings.Metrics == firstSet.Metrics);
+            AddAssert("ratings set", () => details.Ratings.Ratings == firstSet.Ratings);
 
             AddStep("set second set", () => details.BeatmapSet = secondSet);
-            AddAssert("ratings set", () => details.Ratings.Metrics == secondSet.Metrics);
+            AddAssert("ratings set", () => details.Ratings.Ratings == secondSet.Ratings);
 
             static BeatmapSetInfo createSet() => new BeatmapSetInfo
             {
-                Metrics = new BeatmapSetMetrics { Ratings = Enumerable.Range(0, 11).Select(_ => RNG.Next(10)).ToArray() },
                 Beatmaps = new List<BeatmapInfo>
                 {
                     new BeatmapInfo
                     {
-                        Metrics = new BeatmapMetrics
+                        OnlineInfo = new APIBeatmap
+                        {
+                            FailTimes = new APIFailTimes
                             {
                                 Fails = Enumerable.Range(1, 100).Select(_ => RNG.Next(10)).ToArray(),
                                 Retries = Enumerable.Range(-2, 100).Select(_ => RNG.Next(10)).ToArray(),
                             },
                         }
+                    }
                 },
                 OnlineInfo = new APIBeatmapSet
                 {
+                    Ratings = Enumerable.Range(0, 11).Select(_ => RNG.Next(10)).ToArray(),
                     Status = BeatmapSetOnlineStatus.Ranked
                 }
             };

osu.Game.Tests/Visual/Online/TestSceneBeatmapSetOverlaySuccessRate.cs

@@ -11,6 +11,7 @@ using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays;
 using osu.Game.Overlays.BeatmapSet;
 using osu.Game.Screens.Select.Details;
@@ -59,18 +60,21 @@ namespace osu.Game.Tests.Visual.Online
             var secondBeatmap = createBeatmap();
 
             AddStep("set first set", () => successRate.BeatmapInfo = firstBeatmap);
-            AddAssert("ratings set", () => successRate.Graph.Metrics == firstBeatmap.Metrics);
+            AddAssert("ratings set", () => successRate.Graph.FailTimes == firstBeatmap.FailTimes);
 
             AddStep("set second set", () => successRate.BeatmapInfo = secondBeatmap);
-            AddAssert("ratings set", () => successRate.Graph.Metrics == secondBeatmap.Metrics);
+            AddAssert("ratings set", () => successRate.Graph.FailTimes == secondBeatmap.FailTimes);
 
             static BeatmapInfo createBeatmap() => new BeatmapInfo
             {
-                Metrics = new BeatmapMetrics
+                OnlineInfo = new APIBeatmap
+                {
+                    FailTimes = new APIFailTimes
                     {
                         Fails = Enumerable.Range(1, 100).Select(_ => RNG.Next(10)).ToArray(),
                         Retries = Enumerable.Range(-2, 100).Select(_ => RNG.Next(10)).ToArray(),
                     }
+                }
             };
         }
 
@@ -79,13 +83,16 @@ namespace osu.Game.Tests.Visual.Online
         {
             AddStep("set beatmap", () => successRate.BeatmapInfo = new BeatmapInfo
             {
-                Metrics = new BeatmapMetrics
+                OnlineInfo = new APIBeatmap
+                {
+                    FailTimes = new APIFailTimes
                     {
                         Fails = Enumerable.Range(1, 100).ToArray(),
                     }
+                }
             });
-            AddAssert("graph max values correct",
+
-                () => successRate.ChildrenOfType<BarGraph>().All(graph => graph.MaxValue == 100));
+            AddAssert("graph max values correct", () => successRate.ChildrenOfType<BarGraph>().All(graph => graph.MaxValue == 100));
         }
 
         [Test]
@@ -93,11 +100,13 @@ namespace osu.Game.Tests.Visual.Online
         {
             AddStep("set beatmap", () => successRate.BeatmapInfo = new BeatmapInfo
             {
-                Metrics = new BeatmapMetrics()
+                OnlineInfo = new APIBeatmap
+                {
+                    FailTimes = new APIFailTimes(),
+                }
             });
 
-            AddAssert("graph max values correct",
+            AddAssert("graph max values correct", () => successRate.ChildrenOfType<BarGraph>().All(graph => graph.MaxValue == 0));
-                () => successRate.ChildrenOfType<BarGraph>().All(graph => graph.MaxValue == 0));
         }
 
         private class GraphExposingSuccessRate : SuccessRate

osu.Game.Tests/Visual/Online/TestSceneChatOverlay.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net;
 using JetBrains.Annotations;
 using NUnit.Framework;
 using osu.Framework.Allocation;
@@ -105,7 +106,7 @@ namespace osu.Game.Tests.Visual.Online
                             }
                             else
                             {
-                                getUser.TriggerFailure(new Exception());
+                                getUser.TriggerFailure(new WebException());
                             }
 
                             return true;
@@ -189,8 +190,8 @@ namespace osu.Game.Tests.Visual.Online
 
             for (int zeroBasedIndex = 0; zeroBasedIndex < 10; ++zeroBasedIndex)
             {
-                var oneBasedIndex = zeroBasedIndex + 1;
+                int oneBasedIndex = zeroBasedIndex + 1;
-                var targetNumberKey = oneBasedIndex % 10;
+                int targetNumberKey = oneBasedIndex % 10;
                 var targetChannel = channels[zeroBasedIndex];
                 AddStep($"Press Alt+{targetNumberKey}", () => pressChannelHotkey(targetNumberKey));
                 AddAssert($"Channel #{oneBasedIndex} is selected", () => currentChannel == targetChannel);

osu.Game.Tests/Visual/Online/TestSceneRankGraph.cs

@@ -24,10 +24,10 @@ namespace osu.Game.Tests.Visual.Online
         {
             RankGraph graph;
 
-            var data = new int[89];
+            int[] data = new int[89];
-            var dataWithZeros = new int[89];
+            int[] dataWithZeros = new int[89];
-            var smallData = new int[89];
+            int[] smallData = new int[89];
-            var edgyData = new int[89];
+            int[] edgyData = new int[89];
 
             for (int i = 0; i < 89; i++)
                 data[i] = dataWithZeros[i] = (i + 1) * 1000;