Merge remote-tracking branch 'upstream/master' into catch-combo-counter

osu.Game.Rulesets.Catch/Skinning/LegacyComboCounter.cs

@@ -145,8 +145,6 @@ namespace osu.Game.Rulesets.Catch.Skinning
                 this.fontOverlap = fontOverlap;
             }
 
-            public override void Increment(int amount) => Current.Value += amount;
-
             protected override double GetProportionalDuration(int currentValue, int newValue)
             {
                 return Math.Abs(newValue - currentValue) * 75.0;

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

@@ -23,6 +23,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         [TestCase(LegacyMods.Perfect | LegacyMods.SuddenDeath, new[] { typeof(ManiaModPerfect) })]
         [TestCase(LegacyMods.Perfect | LegacyMods.SuddenDeath | LegacyMods.DoubleTime, new[] { typeof(ManiaModDoubleTime), typeof(ManiaModPerfect) })]
         [TestCase(LegacyMods.Random | LegacyMods.SuddenDeath, new[] { typeof(ManiaModRandom), typeof(ManiaModSuddenDeath) })]
+        [TestCase(LegacyMods.Flashlight | LegacyMods.Mirror, new[] { typeof(ManiaModFlashlight), typeof(ManiaModMirror) })]
         public new void Test(LegacyMods legacyMods, Type[] expectedMods) => base.Test(legacyMods, expectedMods);
 
         protected override Ruleset CreateRuleset() => new ManiaRuleset();

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

@@ -0,0 +1,117 @@
+// 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.Extensions.TypeExtensions;
+using osu.Framework.Screens;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Replays;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Replays;
+using osu.Game.Rulesets.Replays;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestSceneOutOfOrderHits : RateAdjustedBeatmapTestScene
+    {
+        [Test]
+        public void TestPreviousHitWindowDoesNotExtendPastNextObject()
+        {
+            var objects = new List<ManiaHitObject>();
+            var frames = new List<ReplayFrame>();
+
+            for (int i = 0; i < 7; i++)
+            {
+                double time = 1000 + i * 100;
+
+                objects.Add(new Note { StartTime = time });
+
+                if (i > 0)
+                {
+                    frames.Add(new ManiaReplayFrame(time + 10, ManiaAction.Key1));
+                    frames.Add(new ManiaReplayFrame(time + 11));
+                }
+            }
+
+            performTest(objects, frames);
+
+            addJudgementAssert(objects[0], HitResult.Miss);
+
+            for (int i = 1; i < 7; i++)
+            {
+                addJudgementAssert(objects[i], HitResult.Perfect);
+                addJudgementOffsetAssert(objects[i], 10);
+            }
+        }
+
+        private void addJudgementAssert(ManiaHitObject hitObject, HitResult result)
+        {
+            AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judgement is {result}",
+                () => judgementResults.Single(r => r.HitObject == hitObject).Type == result);
+        }
+
+        private void addJudgementOffsetAssert(ManiaHitObject hitObject, double offset)
+        {
+            AddAssert($"({hitObject.GetType().ReadableName()} @ {hitObject.StartTime}) judged at {offset}",
+                () => Precision.AlmostEquals(judgementResults.Single(r => r.HitObject == hitObject).TimeOffset, offset, 100));
+        }
+
+        private ScoreAccessibleReplayPlayer currentPlayer;
+        private List<JudgementResult> judgementResults;
+
+        private void performTest(List<ManiaHitObject> hitObjects, List<ReplayFrame> frames)
+        {
+            AddStep("load player", () =>
+            {
+                Beatmap.Value = CreateWorkingBeatmap(new ManiaBeatmap(new StageDefinition { Columns = 4 })
+                {
+                    HitObjects = hitObjects,
+                    BeatmapInfo =
+                    {
+                        Ruleset = new ManiaRuleset().RulesetInfo
+                    },
+                });
+
+                Beatmap.Value.Beatmap.ControlPointInfo.Add(0, new DifficultyControlPoint { SpeedMultiplier = 0.1f });
+
+                var p = new ScoreAccessibleReplayPlayer(new Score { Replay = new Replay { Frames = frames } });
+
+                p.OnLoadComplete += _ =>
+                {
+                    p.ScoreProcessor.NewJudgement += result =>
+                    {
+                        if (currentPlayer == p) judgementResults.Add(result);
+                    };
+                };
+
+                LoadScreen(currentPlayer = p);
+                judgementResults = new List<JudgementResult>();
+            });
+
+            AddUntilStep("Beatmap at 0", () => Beatmap.Value.Track.CurrentTime == 0);
+            AddUntilStep("Wait until player is loaded", () => currentPlayer.IsCurrentScreen());
+            AddUntilStep("Wait for completion", () => currentPlayer.ScoreProcessor.HasCompleted.Value);
+        }
+
+        private class ScoreAccessibleReplayPlayer : ReplayPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+
+            protected override bool PauseOnFocusLost => false;
+
+            public ScoreAccessibleReplayPlayer(Score score)
+                : base(score, false, false)
+            {
+            }
+        }
+    }
+}

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -126,6 +126,9 @@ namespace osu.Game.Rulesets.Mania
 
             if (mods.HasFlag(LegacyMods.Random))
                 yield return new ManiaModRandom();
+
+            if (mods.HasFlag(LegacyMods.Mirror))
+                yield return new ManiaModMirror();
         }
 
         public override LegacyMods ConvertToLegacyMods(Mod[] mods)
@@ -175,6 +178,10 @@ namespace osu.Game.Rulesets.Mania
                     case ManiaModFadeIn _:
                         value |= LegacyMods.FadeIn;
                         break;
+
+                    case ManiaModMirror _:
+                        value |= LegacyMods.Mirror;
+                        break;
                 }
             }
 

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

@@ -255,6 +255,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (action != Action.Value)
                 return false;
 
+            if (CheckHittable?.Invoke(this, Time.Current) == false)
+                return false;
+
             // The tail has a lenience applied to it which is factored into the miss window (i.e. the miss judgement will be delayed).
             // But the hold cannot ever be started within the late-lenience window, so we should skip trying to begin the hold during that time.
             // Note: Unlike below, we use the tail's start time to determine the time offset.

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
@@ -8,6 +9,7 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
@@ -34,6 +36,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             }
         }
 
+        /// <summary>
+        /// Whether this <see cref="DrawableManiaHitObject"/> can be hit, given a time value.
+        /// If non-null, judgements will be ignored whilst the function returns false.
+        /// </summary>
+        public Func<DrawableHitObject, double, bool> CheckHittable;
+
         protected DrawableManiaHitObject(ManiaHitObject hitObject)
             : base(hitObject)
         {
@@ -124,6 +132,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                     break;
             }
         }
+
+        /// <summary>
+        /// Causes this <see cref="DrawableManiaHitObject"/> to get missed, disregarding all conditions in implementations of <see cref="DrawableHitObject.CheckForResult"/>.
+        /// </summary>
+        public void MissForcefully() => ApplyResult(r => r.Type = HitResult.Miss);
     }
 
     public abstract class DrawableManiaHitObject<TObject> : DrawableManiaHitObject

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

@@ -64,6 +64,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (action != Action.Value)
                 return false;
 
+            if (CheckHittable?.Invoke(this, Time.Current) == false)
+                return false;
+
             return UpdateResult(true);
         }
 

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

@@ -17,6 +17,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Skinning;
 using osuTK;
 using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
@@ -36,6 +37,7 @@ namespace osu.Game.Rulesets.Mania.UI
         public readonly ColumnHitObjectArea HitObjectArea;
         internal readonly Container TopLevelContainer;
         private readonly DrawablePool<PoolableHitExplosion> hitExplosionPool;
+        private readonly OrderedHitPolicy hitPolicy;
 
         public Container UnderlayElements => HitObjectArea.UnderlayElements;
 
@@ -65,6 +67,8 @@ namespace osu.Game.Rulesets.Mania.UI
                 TopLevelContainer = new Container { RelativeSizeAxes = Axes.Both }
             };
 
+            hitPolicy = new OrderedHitPolicy(HitObjectContainer);
+
             TopLevelContainer.Add(HitObjectArea.Explosions.CreateProxy());
         }
 
@@ -90,6 +94,9 @@ namespace osu.Game.Rulesets.Mania.UI
             hitObject.AccentColour.Value = AccentColour;
             hitObject.OnNewResult += OnNewResult;
 
+            DrawableManiaHitObject maniaObject = (DrawableManiaHitObject)hitObject;
+            maniaObject.CheckHittable = hitPolicy.IsHittable;
+
             HitObjectContainer.Add(hitObject);
         }
 
@@ -104,6 +111,9 @@ namespace osu.Game.Rulesets.Mania.UI
 
         internal void OnNewResult(DrawableHitObject judgedObject, JudgementResult result)
         {
+            if (result.IsHit)
+                hitPolicy.HandleHit(judgedObject);
+
             if (!result.IsHit || !judgedObject.DisplayResult || !DisplayJudgements.Value)
                 return;
 

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

@@ -0,0 +1,78 @@
+// 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 osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    /// <summary>
+    /// Ensures that only the most recent <see cref="HitObject"/> is hittable, affectionately known as "note lock".
+    /// </summary>
+    public class OrderedHitPolicy
+    {
+        private readonly HitObjectContainer hitObjectContainer;
+
+        public OrderedHitPolicy(HitObjectContainer hitObjectContainer)
+        {
+            this.hitObjectContainer = hitObjectContainer;
+        }
+
+        /// <summary>
+        /// Determines whether a <see cref="DrawableHitObject"/> can be hit at a point in time.
+        /// </summary>
+        /// <remarks>
+        /// Only the most recent <see cref="DrawableHitObject"/> can be hit, a previous hitobject's window cannot extend past the next one.
+        /// </remarks>
+        /// <param name="hitObject">The <see cref="DrawableHitObject"/> to check.</param>
+        /// <param name="time">The time to check.</param>
+        /// <returns>Whether <paramref name="hitObject"/> can be hit at the given <paramref name="time"/>.</returns>
+        public bool IsHittable(DrawableHitObject hitObject, double time)
+        {
+            var nextObject = hitObjectContainer.AliveObjects.GetNext(hitObject);
+            return nextObject == null || time < nextObject.HitObject.StartTime;
+        }
+
+        /// <summary>
+        /// Handles a <see cref="HitObject"/> being hit to potentially miss all earlier <see cref="HitObject"/>s.
+        /// </summary>
+        /// <param name="hitObject">The <see cref="HitObject"/> that was hit.</param>
+        public void HandleHit(DrawableHitObject hitObject)
+        {
+            if (!IsHittable(hitObject, hitObject.HitObject.StartTime + hitObject.Result.TimeOffset))
+                throw new InvalidOperationException($"A {hitObject} was hit before it became hittable!");
+
+            foreach (var obj in enumerateHitObjectsUpTo(hitObject.HitObject.StartTime))
+            {
+                if (obj.Judged)
+                    continue;
+
+                ((DrawableManiaHitObject)obj).MissForcefully();
+            }
+        }
+
+        private IEnumerable<DrawableHitObject> enumerateHitObjectsUpTo(double targetTime)
+        {
+            foreach (var obj in hitObjectContainer.AliveObjects)
+            {
+                if (obj.HitObject.GetEndTime() >= targetTime)
+                    yield break;
+
+                yield return obj;
+
+                foreach (var nestedObj in obj.NestedHitObjects)
+                {
+                    if (nestedObj.HitObject.GetEndTime() >= targetTime)
+                        break;
+
+                    yield return nestedObj;
+                }
+            }
+        }
+    }
+}

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

@@ -9,6 +9,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
@@ -62,7 +63,8 @@ namespace osu.Game.Rulesets.Osu.Tests
             drawableSpinner = new TestDrawableSpinner(spinner, auto)
             {
                 Anchor = Anchor.Centre,
-                Depth = depthIndex++
+                Depth = depthIndex++,
+                Scale = new Vector2(0.75f)
             };
 
             foreach (var mod in SelectedMods.Value.OfType<IApplicableToDrawableHitObjects>())

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

@@ -22,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected override float SamplePlaybackPosition => HitObject.X / OsuPlayfield.BASE_SIZE.X;
 
         /// <summary>
-        /// Whether this <see cref="DrawableOsuHitObject"/> can be hit.
+        /// Whether this <see cref="DrawableOsuHitObject"/> can be hit, given a time value.
         /// If non-null, judgements will be ignored (resulting in a shake) whilst the function returns false.
         /// </summary>
         public Func<DrawableHitObject, double, bool> CheckHittable;

osu.Game.Rulesets.Osu/Replays/OsuAutoGenerator.cs

@@ -154,8 +154,12 @@ namespace osu.Game.Rulesets.Osu.Replays
             // The startPosition for the slider should not be its .Position, but the point on the circle whose tangent crosses the current cursor position
             // We also modify spinnerDirection so it spins in the direction it enters the spin circle, to make a smooth transition.
             // TODO: Shouldn't the spinner always spin in the same direction?
-            if (h is Spinner)
+            if (h is Spinner spinner)
             {
+                // spinners with 0 spins required will auto-complete - don't bother
+                if (spinner.SpinsRequired == 0)
+                    return;
+
                 calcSpinnerStartPosAndDirection(((OsuReplayFrame)Frames[^1]).Position, out startPosition, out spinnerDirection);
 
                 Vector2 spinCentreOffset = SPINNER_CENTRE - ((OsuReplayFrame)Frames[^1]).Position;

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

@@ -22,11 +22,11 @@ namespace osu.Game.Rulesets.Osu.Skinning
     {
         private DrawableSpinner drawableSpinner;
         private Sprite disc;
+        private Sprite metreSprite;
         private Container metre;
 
-        private const float background_y_offset = 20;
-
         private const float sprite_scale = 1 / 1.6f;
+        private const float final_metre_height = 692 * sprite_scale;
 
         [BackgroundDependencyLoader]
         private void load(ISkinSource source, DrawableHitObject drawableObject)
@@ -35,50 +35,58 @@ namespace osu.Game.Rulesets.Osu.Skinning
 
             RelativeSizeAxes = Axes.Both;
 
-            InternalChildren = new Drawable[]
+            InternalChild = new Container
             {
-                new Sprite
+                // the old-style spinner relied heavily on absolute screen-space coordinate values.
+                // wrap everything in a container simulating absolute coords to preserve alignment
+                // as there are skins that depend on it.
+                Width = 640,
+                Height = 480,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Children = new Drawable[]
                 {
-                    Anchor = Anchor.BottomCentre,
-                    Origin = Anchor.BottomCentre,
-                    Texture = source.GetTexture("spinner-background"),
-                    Y = background_y_offset,
-                    Scale = new Vector2(sprite_scale)
-                },
-                disc = new Sprite
-                {
-                    Anchor = Anchor.Centre,
-                    Origin = Anchor.Centre,
-                    Texture = source.GetTexture("spinner-circle"),
-                    Scale = new Vector2(sprite_scale)
-                },
-                metre = new Container
-                {
-                    Anchor = Anchor.BottomCentre,
-                    Origin = Anchor.BottomCentre,
-                    Y = background_y_offset,
-                    Masking = true,
-                    Child = new Sprite
+                    new Sprite
                     {
-                        Texture = source.GetTexture("spinner-metre"),
-                        Anchor = Anchor.BottomCentre,
-                        Origin = Anchor.BottomCentre,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Texture = source.GetTexture("spinner-background"),
+                        Scale = new Vector2(sprite_scale)
                     },
-                    Scale = new Vector2(0.625f)
+                    disc = new Sprite
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Texture = source.GetTexture("spinner-circle"),
+                        Scale = new Vector2(sprite_scale)
+                    },
+                    metre = new Container
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        // this anchor makes no sense, but that's what stable uses.
+                        Anchor = Anchor.TopLeft,
+                        Origin = Anchor.TopLeft,
+                        // adjustment for stable (metre has additional offset)
+                        Margin = new MarginPadding { Top = 20 },
+                        Masking = true,
+                        Child = metreSprite = new Sprite
+                        {
+                            Texture = source.GetTexture("spinner-metre"),
+                            Anchor = Anchor.TopLeft,
+                            Origin = Anchor.TopLeft,
+                            Scale = new Vector2(0.625f)
+                        }
+                    }
                 }
             };
         }
 
-        private Vector2 metreFinalSize;
-
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
             this.FadeOut();
             drawableSpinner.State.BindValueChanged(updateStateTransforms, true);
-
-            metreFinalSize = metre.Size = metre.Child.Size;
         }
 
         private void updateStateTransforms(ValueChangedEvent<ArmedState> state)
@@ -93,7 +101,16 @@ namespace osu.Game.Rulesets.Osu.Skinning
         {
             base.Update();
             disc.Rotation = drawableSpinner.RotationTracker.Rotation;
-            metre.Height = getMetreHeight(drawableSpinner.Progress);
+
+            // 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);
+
+            // 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,
+            // and then move the sprite back up the same amount to keep its position absolute.
+            metre.Y = final_metre_height - metreHeight;
+            metreSprite.Y = -metre.Y;
         }
 
         private const int total_bars = 10;
@@ -108,7 +125,7 @@ namespace osu.Game.Rulesets.Osu.Skinning
             if (RNG.NextBool(((int)progress % 10) / 10f))
                 barCount++;
 
-            return (float)barCount / total_bars * metreFinalSize.Y;
+            return (float)barCount / total_bars * final_metre_height;
         }
     }
 }

osu.Game.Tests/NonVisual/Ranking/UnstableRateTest.cs

@@ -0,0 +1,43 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Ranking.Statistics;
+
+namespace osu.Game.Tests.NonVisual.Ranking
+{
+    [TestFixture]
+    public class UnstableRateTest
+    {
+        [Test]
+        public void TestDistributedHits()
+        {
+            var events = Enumerable.Range(-5, 11)
+                                   .Select(t => new HitEvent(t - 5, HitResult.Great, new HitObject(), null, null));
+
+            var unstableRate = new UnstableRate(events);
+
+            Assert.IsTrue(Precision.AlmostEquals(unstableRate.Value, 10 * Math.Sqrt(10)));
+        }
+
+        [Test]
+        public void TestMissesAndEmptyWindows()
+        {
+            var events = new[]
+            {
+                new HitEvent(-100, HitResult.Miss, new HitObject(), null, null),
+                new HitEvent(0, HitResult.Great, new HitObject(), null, null),
+                new HitEvent(200, HitResult.Meh, new HitObject { HitWindows = HitWindows.Empty }, null, null),
+            };
+
+            var unstableRate = new UnstableRate(events);
+
+            Assert.AreEqual(0, unstableRate.Value);
+        }
+    }
+}

osu.Game.Tests/Visual/Ranking/TestSceneHitEventTimingDistributionGraph.cs

@@ -35,6 +35,18 @@ namespace osu.Game.Tests.Visual.Ranking
             createTest(new List<HitEvent>());
         }
 
+        [Test]
+        public void TestMissesDontShow()
+        {
+            createTest(Enumerable.Range(0, 100).Select(i =>
+            {
+                if (i % 2 == 0)
+                    return new HitEvent(0, HitResult.Perfect, new HitCircle(), new HitCircle(), null);
+
+                return new HitEvent(30, HitResult.Miss, new HitCircle(), new HitCircle(), null);
+            }).ToList());
+        }
+
         private void createTest(List<HitEvent> events) => AddStep("create test", () =>
         {
             Children = new Drawable[]

osu.Game.Tests/Visual/Ranking/TestSceneResultsScreen.cs

@@ -13,6 +13,7 @@ using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Scoring;
@@ -212,6 +213,25 @@ namespace osu.Game.Tests.Visual.Ranking
             AddAssert("expanded panel still on screen", () => this.ChildrenOfType<ScorePanel>().Single(p => p.State == PanelState.Expanded).ScreenSpaceDrawQuad.TopLeft.X > 0);
         }
 
+        [Test]
+        public void TestDownloadButtonInitiallyDisabled()
+        {
+            TestResultsScreen screen = null;
+
+            AddStep("load results", () => Child = new TestResultsContainer(screen = createResultsScreen()));
+
+            AddAssert("download button is disabled", () => !screen.ChildrenOfType<DownloadButton>().Single().Enabled.Value);
+
+            AddStep("click contracted panel", () =>
+            {
+                var contractedPanel = this.ChildrenOfType<ScorePanel>().First(p => p.State == PanelState.Contracted && p.ScreenSpaceDrawQuad.TopLeft.X > screen.ScreenSpaceDrawQuad.TopLeft.X);
+                InputManager.MoveMouseTo(contractedPanel);
+                InputManager.Click(MouseButton.Left);
+            });
+
+            AddAssert("download button is enabled", () => screen.ChildrenOfType<DownloadButton>().Single().Enabled.Value);
+        }
+
         private class TestResultsContainer : Container
         {
             [Cached(typeof(Player))]
@@ -255,6 +275,7 @@ namespace osu.Game.Tests.Visual.Ranking
                 {
                     var score = new TestScoreInfo(new OsuRuleset().RulesetInfo);
                     score.TotalScore += 10 - i;
+                    score.Hash = $"test{i}";
                     scores.Add(score);
                 }
 

osu.Game/Beatmaps/Legacy/LegacyMods.cs

@@ -38,5 +38,6 @@ namespace osu.Game.Beatmaps.Legacy
         Key1 = 1 << 26,
         Key3 = 1 << 27,
         Key2 = 1 << 28,
+        Mirror = 1 << 30,
     }
 }

osu.Game/Graphics/UserInterface/PercentageCounter.cs

@@ -40,10 +40,5 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override OsuSpriteText CreateSpriteText()
             => base.CreateSpriteText().With(s => s.Font = s.Font.With(size: 20f, fixedWidth: true));
-
-        public override void Increment(double amount)
-        {
-            Current.Value += amount;
-        }
     }
 }

osu.Game/Graphics/UserInterface/RollingCounter.cs

@@ -57,20 +57,12 @@ namespace osu.Game.Graphics.UserInterface
             }
         }
 
-        public abstract void Increment(T amount);
-
         /// <summary>
         /// Skeleton of a numeric counter which value rolls over time.
         /// </summary>
         protected RollingCounter()
         {
             AutoSizeAxes = Axes.Both;
-
-            Current.ValueChanged += val =>
-            {
-                if (IsLoaded)
-                    TransformCount(DisplayedCount, val.NewValue);
-            };
         }
 
         [BackgroundDependencyLoader]
@@ -81,6 +73,13 @@ namespace osu.Game.Graphics.UserInterface
             Child = displayedCountSpriteText;
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Current.BindValueChanged(val => TransformCount(DisplayedCount, val.NewValue), true);
+        }
+
         /// <summary>
         /// Sets count value, bypassing rollover animation.
         /// </summary>

osu.Game/Graphics/UserInterface/ScoreCounter.cs

@@ -51,10 +51,5 @@ namespace osu.Game.Graphics.UserInterface
 
         protected override OsuSpriteText CreateSpriteText()
             => base.CreateSpriteText().With(s => s.Font = s.Font.With(fixedWidth: true));
-
-        public override void Increment(double amount)
-        {
-            Current.Value += amount;
-        }
     }
 }

osu.Game/Graphics/UserInterface/SimpleComboCounter.cs

@@ -33,11 +33,6 @@ namespace osu.Game.Graphics.UserInterface
             return Math.Abs(currentValue - newValue) * RollingDuration * 100.0f;
         }
 
-        public override void Increment(int amount)
-        {
-            Current.Value += amount;
-        }
-
         protected override OsuSpriteText CreateSpriteText()
             => base.CreateSpriteText().With(s => s.Font = s.Font.With(size: 20f));
     }

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

@@ -68,7 +68,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
             }, true);
         }
 
-        private float getZoomLevelForVisibleMilliseconds(double milliseconds) => (float)(track.Length / milliseconds);
+        private float getZoomLevelForVisibleMilliseconds(double milliseconds) => Math.Max(1, (float)(track.Length / milliseconds));
 
         /// <summary>
         /// The timeline's scroll position in the last frame.

osu.Game/Screens/Edit/Editor.cs

@@ -284,7 +284,7 @@ namespace osu.Game.Screens.Edit
             // this is a special case to handle the "pivot" scenario.
             // if we are precise scrolling in one direction then change our mind and scroll backwards,
             // the existing accumulation should be applied in the inverse direction to maintain responsiveness.
-            if (Math.Sign(scrollAccumulation) != scrollDirection)
+            if (scrollAccumulation != 0 && Math.Sign(scrollAccumulation) != scrollDirection)
                 scrollAccumulation = scrollDirection * (precision - Math.Abs(scrollAccumulation));
 
             scrollAccumulation += scrollComponent * (e.IsPrecise ? 0.1 : 1);

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

@@ -1,32 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.Graphics;
-using osu.Game.Graphics.UserInterface;
-
-namespace osu.Game.Screens.Play.HUD
-{
-    /// <summary>
-    /// Used to display combo with a roll-up animation in results screen.
-    /// </summary>
-    public class ComboResultCounter : RollingCounter<long>
-    {
-        protected override double RollingDuration => 500;
-        protected override Easing RollingEasing => Easing.Out;
-
-        protected override double GetProportionalDuration(long currentValue, long newValue)
-        {
-            return currentValue > newValue ? currentValue - newValue : newValue - currentValue;
-        }
-
-        protected override string FormatCount(long count)
-        {
-            return $@"{count}x";
-        }
-
-        public override void Increment(long amount)
-        {
-            Current.Value += amount;
-        }
-    }
-}

osu.Game/Screens/Ranking/Expanded/Statistics/AccuracyStatistic.cs

@@ -46,9 +46,6 @@ namespace osu.Game.Screens.Ranking.Expanded.Statistics
 
             protected override string FormatCount(double count) => count.FormatAccuracy();
 
-            public override void Increment(double amount)
-                => Current.Value += amount;
-
             protected override OsuSpriteText CreateSpriteText() => base.CreateSpriteText().With(s =>
             {
                 s.Font = OsuFont.Torus.With(size: 20, fixedWidth: true);

osu.Game/Screens/Ranking/Expanded/Statistics/CounterStatistic.cs

@@ -49,9 +49,6 @@ namespace osu.Game.Screens.Ranking.Expanded.Statistics
                 s.Font = OsuFont.Torus.With(size: 20, fixedWidth: true);
                 s.Spacing = new Vector2(-2, 0);
             });
-
-            public override void Increment(int amount)
-                => Current.Value += amount;
         }
     }
 }

osu.Game/Screens/Ranking/Expanded/TotalScoreCounter.cs

@@ -36,8 +36,5 @@ namespace osu.Game.Screens.Ranking.Expanded
             s.Font = OsuFont.Torus.With(size: 60, weight: FontWeight.Light, fixedWidth: true);
             s.Spacing = new Vector2(-5, 0);
         });
-
-        public override void Increment(long amount)
-            => Current.Value += amount;
     }
 }

osu.Game/Screens/Ranking/ReplayDownloadButton.cs

@@ -74,23 +74,33 @@ namespace osu.Game.Screens.Ranking
             {
                 button.State.Value = state.NewValue;
 
-                switch (replayAvailability)
-                {
-                    case ReplayAvailability.Local:
-                        button.TooltipText = @"watch replay";
-                        break;
-
-                    case ReplayAvailability.Online:
-                        button.TooltipText = @"download replay";
-                        break;
-
-                    default:
-                        button.TooltipText = @"replay unavailable";
-                        break;
-                }
+                updateTooltip();
             }, true);
 
-            button.Enabled.Value = replayAvailability != ReplayAvailability.NotAvailable;
+            Model.BindValueChanged(_ =>
+            {
+                button.Enabled.Value = replayAvailability != ReplayAvailability.NotAvailable;
+
+                updateTooltip();
+            }, true);
+        }
+
+        private void updateTooltip()
+        {
+            switch (replayAvailability)
+            {
+                case ReplayAvailability.Local:
+                    button.TooltipText = @"watch replay";
+                    break;
+
+                case ReplayAvailability.Online:
+                    button.TooltipText = @"download replay";
+                    break;
+
+                default:
+                    button.TooltipText = @"replay unavailable";
+                    break;
+            }
         }
 
         private enum ReplayAvailability

osu.Game/Screens/Ranking/Statistics/HitEventTimingDistributionGraph.cs

@@ -48,7 +48,7 @@ namespace osu.Game.Screens.Ranking.Statistics
         /// <param name="hitEvents">The <see cref="HitEvent"/>s to display the timing distribution of.</param>
         public HitEventTimingDistributionGraph(IReadOnlyList<HitEvent> hitEvents)
         {
-            this.hitEvents = hitEvents.Where(e => !(e.HitObject.HitWindows is HitWindows.EmptyHitWindows)).ToList();
+            this.hitEvents = hitEvents.Where(e => !(e.HitObject.HitWindows is HitWindows.EmptyHitWindows) && e.Result != HitResult.Miss).ToList();
         }
 
         [BackgroundDependencyLoader]

osu.Game/Screens/Ranking/Statistics/SimpleStatisticItem.cs

@@ -59,12 +59,19 @@ namespace osu.Game.Screens.Ranking.Statistics
     /// </summary>
     public class SimpleStatisticItem<TValue> : SimpleStatisticItem
     {
+        private TValue value;
+
         /// <summary>
         /// The statistic's value to be displayed.
         /// </summary>
         public new TValue Value
         {
-            set => base.Value = DisplayValue(value);
+            get => value;
+            set
+            {
+                this.value = value;
+                base.Value = DisplayValue(value);
+            }
         }
 
         /// <summary>

osu.Game/Screens/Ranking/Statistics/UnstableRate.cs

@@ -20,7 +20,8 @@ namespace osu.Game.Screens.Ranking.Statistics
         public UnstableRate(IEnumerable<HitEvent> hitEvents)
             : base("Unstable Rate")
         {
-            var timeOffsets = hitEvents.Select(ev => ev.TimeOffset).ToArray();
+            var timeOffsets = hitEvents.Where(e => !(e.HitObject.HitWindows is HitWindows.EmptyHitWindows) && e.Result != HitResult.Miss)
+                                       .Select(ev => ev.TimeOffset).ToArray();
             Value = 10 * standardDeviation(timeOffsets);
         }
 

osu.Game/Screens/Select/BeatmapInfoWedge.cs

@@ -27,6 +27,7 @@ using osu.Framework.Logging;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Ranking.Expanded;
 
 namespace osu.Game.Screens.Select
 {
@@ -222,10 +223,20 @@ namespace osu.Game.Screens.Select
                         Direction = FillDirection.Vertical,
                         Padding = new MarginPadding { Top = 14, Right = shear_width / 2 },
                         AutoSizeAxes = Axes.Both,
-                        Children = new Drawable[]
+                        Shear = wedged_container_shear,
+                        Children = new[]
                         {
+                            createStarRatingDisplay(beatmapInfo).With(display =>
+                            {
+                                display.Anchor = Anchor.TopRight;
+                                display.Origin = Anchor.TopRight;
+                                display.Shear = -wedged_container_shear;
+                            }),
                             StatusPill = new BeatmapSetOnlineStatusPill
                             {
+                                Anchor = Anchor.TopRight,
+                                Origin = Anchor.TopRight,
+                                Shear = -wedged_container_shear,
                                 TextSize = 11,
                                 TextPadding = new MarginPadding { Horizontal = 8, Vertical = 2 },
                                 Status = beatmapInfo.Status,
@@ -282,6 +293,13 @@ namespace osu.Game.Screens.Select
                     StatusPill.Hide();
             }
 
+            private static Drawable createStarRatingDisplay(BeatmapInfo beatmapInfo) => beatmapInfo.StarDifficulty > 0
+                ? new StarRatingDisplay(beatmapInfo)
+                {
+                    Margin = new MarginPadding { Bottom = 5 }
+                }
+                : Empty();
+
             private void setMetadata(string source)
             {
                 ArtistLabel.Text = artistBinding.Value;