Refactor HitWindows for legibility

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

@@ -6,6 +6,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Catch.Objects
 {

osu.Game.Rulesets.Catch/Scoring/CatchHitWindows.cs

@@ -1,10 +1,9 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 
-namespace osu.Game.Rulesets.Catch.Objects
+namespace osu.Game.Rulesets.Catch.Scoring
 {
     public class CatchHitWindows : HitWindows
     {

osu.Game.Rulesets.Catch/Scoring/CatchScoreProcessor.cs

@@ -4,7 +4,6 @@
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs

@@ -11,9 +11,9 @@ using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mania.Difficulty.Skills;
 using osu.Game.Rulesets.Mania.Mods;
-using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Difficulty
 {
@@ -42,7 +42,7 @@ namespace osu.Game.Rulesets.Mania.Difficulty
                 StarRating = difficultyValue(skills) * star_scaling_factor,
                 Mods = mods,
                 // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be removed in the future
-                GreatHitWindow = (int)(hitWindows.Great / 2) / clockRate,
+                GreatHitWindow = (int)(hitWindows.WindowFor(HitResult.Great)) / clockRate,
                 Skills = skills
             };
         }

osu.Game.Rulesets.Mania/Objects/HoldNote.cs

@@ -5,8 +5,8 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects
 {

osu.Game.Rulesets.Mania/Objects/HoldNoteTick.cs

@@ -3,7 +3,7 @@
 
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Judgements;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects
 {

osu.Game.Rulesets.Mania/Objects/ManiaHitObject.cs

@@ -3,7 +3,9 @@
 
 using osu.Framework.Bindables;
 using osu.Game.Rulesets.Mania.Objects.Types;
+using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects
 {

osu.Game.Rulesets.Mania/Objects/ManiaHitWindows.cs

@@ -1,35 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Collections.Generic;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Mania.Objects
-{
-    public class ManiaHitWindows : HitWindows
-    {
-        private static readonly IReadOnlyDictionary<HitResult, (double od0, double od5, double od10)> base_ranges = new Dictionary<HitResult, (double, double, double)>
-        {
-            { HitResult.Perfect, (44.8, 38.8, 27.8) },
-            { HitResult.Great, (128, 98, 68) },
-            { HitResult.Good, (194, 164, 134) },
-            { HitResult.Ok, (254, 224, 194) },
-            { HitResult.Meh, (302, 272, 242) },
-            { HitResult.Miss, (376, 346, 316) },
-        };
-
-        public override bool IsHitResultAllowed(HitResult result) => true;
-
-        public override void SetDifficulty(double difficulty)
-        {
-            Perfect = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Perfect]);
-            Great = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Great]);
-            Good = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Good]);
-            Ok = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Ok]);
-            Meh = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Meh]);
-            Miss = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Miss]);
-        }
-    }
-}

osu.Game.Rulesets.Mania/Scoring/ManiaHitWindows.cs

@@ -0,0 +1,11 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Mania.Scoring
+{
+    public class ManiaHitWindows : HitWindows
+    {
+    }
+}

osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs

@@ -4,7 +4,6 @@
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             Debug.Assert(drawableHitObject.HitObject.HitWindows != null);
 
-            double delay = drawableHitObject.HitObject.StartTime - (drawableHitObject.HitObject.HitWindows.HalfWindowFor(HitResult.Miss) + RNG.Next(0, 300)) - Time.Current;
+            double delay = drawableHitObject.HitObject.StartTime - (drawableHitObject.HitObject.HitWindows.WindowFor(HitResult.Miss) + RNG.Next(0, 300)) - Time.Current;
             Scheduler.AddDelayed(() => drawableHitObject.TriggerJudgement(), delay);
 
             return drawableHitObject;

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

@@ -9,11 +9,12 @@ using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Osu.Difficulty.Skills;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Difficulty
 {
@@ -39,7 +40,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             hitWindows.SetDifficulty(beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty);
 
             // Todo: These int casts are temporary to achieve 1:1 results with osu!stable, and should be removed in the future
-            double hitWindowGreat = (int)(hitWindows.Great / 2) / clockRate;
+            double hitWindowGreat = (int)(hitWindows.WindowFor(HitResult.Great)) / clockRate;
             double preempt = (int)BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / clockRate;
 
             int maxCombo = beatmap.HitObjects.Count;

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

@@ -10,8 +10,8 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using osuTK;
 using osu.Game.Rulesets.Scoring;
+using osuTK;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
@@ -102,7 +102,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             if (result == HitResult.None)
             {
-                Shake(Math.Abs(timeOffset) - HitObject.HitWindows.HalfWindowFor(HitResult.Miss));
+                Shake(Math.Abs(timeOffset) - HitObject.HitWindows.WindowFor(HitResult.Miss));
                 return;
             }
 
@@ -134,7 +134,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     hitArea.HitAction = null;
 
                     // override lifetime end as FadeIn may have been changed externally, causing out expiration to be too early.
-                    LifetimeEnd = HitObject.StartTime + HitObject.HitWindows.HalfWindowFor(HitResult.Miss);
+                    LifetimeEnd = HitObject.StartTime + HitObject.HitWindows.WindowFor(HitResult.Miss);
                     break;
 
                 case ArmedState.Miss:

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

@@ -9,8 +9,8 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Objects.Drawables;
-using osuTK;
 using osu.Game.Rulesets.Scoring;
+using osuTK;
 using osu.Game.Skinning;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables

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

@@ -8,9 +8,9 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osuTK;
 using osuTK.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {

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

@@ -13,8 +13,8 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Screens.Ranking;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Ranking;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {

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

@@ -7,6 +7,8 @@ using osu.Game.Rulesets.Objects;
 using osuTK;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {

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

@@ -1,29 +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 System.Collections.Generic;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Osu.Objects
-{
-    public class OsuHitWindows : HitWindows
-    {
-        private static readonly IReadOnlyDictionary<HitResult, (double od0, double od5, double od10)> base_ranges = new Dictionary<HitResult, (double, double, double)>
-        {
-            { HitResult.Great, (160, 100, 40) },
-            { HitResult.Good, (280, 200, 120) },
-            { HitResult.Meh, (400, 300, 200) },
-            { HitResult.Miss, (400, 400, 400) },
-        };
-
-        public override void SetDifficulty(double difficulty)
-        {
-            Great = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Great]);
-            Good = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Good]);
-            Meh = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Meh]);
-            Miss = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Miss]);
-        }
-    }
-}

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

@@ -5,8 +5,8 @@ using System;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {

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

@@ -13,6 +13,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {

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

@@ -5,6 +5,7 @@ using osu.Framework.Bindables;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {

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

@@ -4,8 +4,8 @@
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {

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

@@ -6,8 +6,8 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {

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

@@ -10,9 +10,9 @@ using System.Diagnostics;
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Replays;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Scoring;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Replays
@@ -118,29 +118,29 @@ namespace osu.Game.Rulesets.Osu.Replays
             Debug.Assert(hitWindows != null);
 
             // Make the cursor stay at a hitObject as long as possible (mainly for autopilot).
-            if (h.StartTime - hitWindows.HalfWindowFor(HitResult.Miss) > endTime + hitWindows.HalfWindowFor(HitResult.Meh) + 50)
+            if (h.StartTime - hitWindows.WindowFor(HitResult.Miss) > endTime + hitWindows.WindowFor(HitResult.Meh) + 50)
             {
                 if (!(prev is Spinner) && h.StartTime - endTime < 1000)
-                    AddFrameToReplay(new OsuReplayFrame(endTime + hitWindows.HalfWindowFor(HitResult.Meh), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
+                    AddFrameToReplay(new OsuReplayFrame(endTime + hitWindows.WindowFor(HitResult.Meh), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
 
                 if (!(h is Spinner))
-                    AddFrameToReplay(new OsuReplayFrame(h.StartTime - hitWindows.HalfWindowFor(HitResult.Miss), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
+                    AddFrameToReplay(new OsuReplayFrame(h.StartTime - hitWindows.WindowFor(HitResult.Miss), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
             }
-            else if (h.StartTime - hitWindows.HalfWindowFor(HitResult.Meh) > endTime + hitWindows.HalfWindowFor(HitResult.Meh) + 50)
+            else if (h.StartTime - hitWindows.WindowFor(HitResult.Meh) > endTime + hitWindows.WindowFor(HitResult.Meh) + 50)
             {
                 if (!(prev is Spinner) && h.StartTime - endTime < 1000)
-                    AddFrameToReplay(new OsuReplayFrame(endTime + hitWindows.HalfWindowFor(HitResult.Meh), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
+                    AddFrameToReplay(new OsuReplayFrame(endTime + hitWindows.WindowFor(HitResult.Meh), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
 
                 if (!(h is Spinner))
-                    AddFrameToReplay(new OsuReplayFrame(h.StartTime - hitWindows.HalfWindowFor(HitResult.Meh), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
+                    AddFrameToReplay(new OsuReplayFrame(h.StartTime - hitWindows.WindowFor(HitResult.Meh), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
             }
-            else if (h.StartTime - hitWindows.HalfWindowFor(HitResult.Good) > endTime + hitWindows.HalfWindowFor(HitResult.Good) + 50)
+            else if (h.StartTime - hitWindows.WindowFor(HitResult.Good) > endTime + hitWindows.WindowFor(HitResult.Good) + 50)
             {
                 if (!(prev is Spinner) && h.StartTime - endTime < 1000)
-                    AddFrameToReplay(new OsuReplayFrame(endTime + hitWindows.HalfWindowFor(HitResult.Good), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
+                    AddFrameToReplay(new OsuReplayFrame(endTime + hitWindows.WindowFor(HitResult.Good), new Vector2(prev.StackedEndPosition.X, prev.StackedEndPosition.Y)));
 
                 if (!(h is Spinner))
-                    AddFrameToReplay(new OsuReplayFrame(h.StartTime - hitWindows.HalfWindowFor(HitResult.Good), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
+                    AddFrameToReplay(new OsuReplayFrame(h.StartTime - hitWindows.WindowFor(HitResult.Good), new Vector2(h.StackedPosition.X, h.StackedPosition.Y)));
             }
         }
 

osu.Game.Rulesets.Osu/Scoring/OsuHitWindows.cs

@@ -0,0 +1,20 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Scoring
+{
+    public class OsuHitWindows : HitWindows
+    {
+        private static readonly DifficultyRange[] osu_ranges =
+        {
+            new DifficultyRange(HitResult.Great, 80, 50, 20),
+            new DifficultyRange(HitResult.Good, 140, 100, 60),
+            new DifficultyRange(HitResult.Meh, 200, 150, 100),
+            new DifficultyRange(HitResult.Miss, 200, 200, 200),
+        };
+
+        protected override DifficultyRange[] GetRanges() => osu_ranges;
+    }
+}

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

@@ -14,13 +14,13 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Judgements;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.Taiko.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.UI;
 using osu.Game.Tests.Visual;
 using osuTK;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Taiko.Tests
 {

osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs

@@ -8,11 +8,12 @@ using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Difficulty.Skills;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Taiko.Difficulty.Skills;
 using osu.Game.Rulesets.Taiko.Mods;
 using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Scoring;
 
 namespace osu.Game.Rulesets.Taiko.Difficulty
 {
@@ -38,7 +39,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                 StarRating = skills.Single().DifficultyValue() * star_scaling_factor,
                 Mods = mods,
                 // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be removed in the future
-                GreatHitWindow = (int)(hitWindows.Great / 2) / clockRate,
+                GreatHitWindow = (int)(hitWindows.WindowFor(HitResult.Great)) / clockRate,
                 MaxCombo = beatmap.HitObjects.Count(h => h is Hit),
                 Skills = skills
             };

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

@@ -105,7 +105,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                     validActionPressed = false;
 
                     UnproxyContent();
-                    this.Delay(HitObject.HitWindows.HalfWindowFor(HitResult.Miss)).Expire();
+                    this.Delay(HitObject.HitWindows.WindowFor(HitResult.Miss)).Expire();
                     break;
 
                 case ArmedState.Miss:

osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs

@@ -6,7 +6,7 @@ using System;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Judgements;
 
 namespace osu.Game.Rulesets.Taiko.Objects

osu.Game.Rulesets.Taiko/Objects/DrumRollTick.cs

@@ -2,7 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Judgements;
 
 namespace osu.Game.Rulesets.Taiko.Objects

osu.Game.Rulesets.Taiko/Objects/StrongHitObject.cs

@@ -2,7 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Judgements;
 
 namespace osu.Game.Rulesets.Taiko.Objects

osu.Game.Rulesets.Taiko/Objects/Swell.cs

@@ -4,7 +4,7 @@
 using System;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Judgements;
 
 namespace osu.Game.Rulesets.Taiko.Objects

osu.Game.Rulesets.Taiko/Objects/SwellTick.cs

@@ -2,7 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Judgements;
 
 namespace osu.Game.Rulesets.Taiko.Objects

osu.Game.Rulesets.Taiko/Objects/TaikoHitObject.cs

@@ -4,7 +4,9 @@
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Judgements;
+using osu.Game.Rulesets.Taiko.Scoring;
 
 namespace osu.Game.Rulesets.Taiko.Objects
 {

osu.Game.Rulesets.Taiko/Objects/TaikoHitWindows.cs

@@ -1,41 +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 System.Collections.Generic;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Taiko.Objects
-{
-    public class TaikoHitWindows : HitWindows
-    {
-        private static readonly IReadOnlyDictionary<HitResult, (double od0, double od5, double od10)> base_ranges = new Dictionary<HitResult, (double, double, double)>
-        {
-            { HitResult.Great, (100, 70, 40) },
-            { HitResult.Good, (240, 160, 100) },
-            { HitResult.Miss, (270, 190, 140) },
-        };
-
-        public override bool IsHitResultAllowed(HitResult result)
-        {
-            switch (result)
-            {
-                case HitResult.Great:
-                case HitResult.Good:
-                case HitResult.Miss:
-                    return true;
-
-                default:
-                    return false;
-            }
-        }
-
-        public override void SetDifficulty(double difficulty)
-        {
-            Great = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Great]);
-            Good = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Good]);
-            Miss = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Miss]);
-        }
-    }
-}

osu.Game.Rulesets.Taiko/Scoring/TaikoHitWindows.cs

@@ -0,0 +1,19 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Taiko.Scoring
+{
+    public class TaikoHitWindows : HitWindows
+    {
+        private static readonly DifficultyRange[] taiko_ranges =
+        {
+            new DifficultyRange(HitResult.Great, 50, 35, 20),
+            new DifficultyRange(HitResult.Good, 120, 80, 50),
+            new DifficultyRange(HitResult.Miss, 135, 95, 70),
+        };
+
+        protected override DifficultyRange[] GetRanges() => taiko_ranges;
+    }
+}

osu.Game.Rulesets.Taiko/Scoring/TaikoScoreProcessor.cs

@@ -3,7 +3,6 @@
 
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Rulesets.UI;

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

@@ -9,8 +9,8 @@ using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.IO.Serialization;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Tests.Resources;
 using osuTK;
 

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

@@ -3,18 +3,18 @@
 
 using NUnit.Framework;
 using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Taiko.Objects;
-using osu.Game.Rulesets.Mania.Objects;
-using osu.Game.Rulesets.Catch.Objects;
 using System;
 using System.Collections.Generic;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Scoring;
 using osu.Framework.MathUtils;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Catch.Scoring;
+using osu.Game.Rulesets.Mania.Scoring;
+using osu.Game.Rulesets.Osu.Scoring;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Taiko.Scoring;
 using osu.Game.Screens.Play.HUD.HitErrorMeters;
 
 namespace osu.Game.Tests.Visual.Gameplay
@@ -36,8 +36,8 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             AddRepeatStep("New random judgement", () => newJudgement(), 40);
 
-            AddRepeatStep("New max negative", () => newJudgement(-hitWindows.HalfWindowFor(HitResult.Meh)), 20);
+            AddRepeatStep("New max negative", () => newJudgement(-hitWindows.WindowFor(HitResult.Meh)), 20);
-            AddRepeatStep("New max positive", () => newJudgement(hitWindows.HalfWindowFor(HitResult.Meh)), 20);
+            AddRepeatStep("New max positive", () => newJudgement(hitWindows.WindowFor(HitResult.Meh)), 20);
             AddStep("New fixed judgement (50ms)", () => newJudgement(50));
         }
 
@@ -85,9 +85,9 @@ namespace osu.Game.Tests.Visual.Gameplay
                 AutoSizeAxes = Axes.Both,
                 Children = new[]
                 {
-                    new SpriteText { Text = $@"Great: {hitWindows?.Great}" },
+                    new SpriteText { Text = $@"Great: {hitWindows?.WindowFor(HitResult.Great)}" },
-                    new SpriteText { Text = $@"Good: {hitWindows?.Good}" },
+                    new SpriteText { Text = $@"Good: {hitWindows?.WindowFor(HitResult.Good)}" },
-                    new SpriteText { Text = $@"Meh: {hitWindows?.Meh}" },
+                    new SpriteText { Text = $@"Meh: {hitWindows?.WindowFor(HitResult.Meh)}" },
                 }
             });
 

osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs

@@ -164,7 +164,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
                 {
                     UpdateInitialTransforms();
 
-                    var judgementOffset = Math.Min(HitObject.HitWindows?.HalfWindowFor(HitResult.Miss) ?? double.MaxValue, Result?.TimeOffset ?? 0);
+                    var judgementOffset = Math.Min(HitObject.HitWindows?.WindowFor(HitResult.Miss) ?? double.MaxValue, Result?.TimeOffset ?? 0);
 
                     using (BeginDelayedSequence(InitialLifetimeOffset + judgementOffset, true))
                     {

osu.Game/Rulesets/Objects/HitObject.cs

@@ -9,6 +9,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Objects
 {

osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHit.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Objects.Legacy.Mania
 {

osu.Game/Rulesets/Objects/Legacy/Mania/ConvertHold.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Objects.Legacy.Mania
 {

osu.Game/Rulesets/Objects/Legacy/Mania/ConvertSlider.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Objects.Legacy.Mania
 {

osu.Game/Rulesets/Objects/Legacy/Mania/ConvertSpinner.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Objects.Legacy.Mania
 {

osu.Game/Rulesets/Objects/Legacy/Osu/ConvertHit.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 using osuTK;
 
 namespace osu.Game.Rulesets.Objects.Legacy.Osu

osu.Game/Rulesets/Objects/Legacy/Osu/ConvertSlider.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 using osuTK;
 
 namespace osu.Game.Rulesets.Objects.Legacy.Osu

osu.Game/Rulesets/Objects/Legacy/Osu/ConvertSpinner.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 using osuTK;
 
 namespace osu.Game.Rulesets.Objects.Legacy.Osu

osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertHit.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Game.Rulesets.Scoring;
+
 namespace osu.Game.Rulesets.Objects.Legacy.Taiko
 {
     /// <summary>

osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertSlider.cs

@@ -1,6 +1,8 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Game.Rulesets.Scoring;
+
 namespace osu.Game.Rulesets.Objects.Legacy.Taiko
 {
     /// <summary>

osu.Game/Rulesets/Objects/Legacy/Taiko/ConvertSpinner.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Objects.Legacy.Taiko
 {

osu.Game/Rulesets/Scoring/HitResult.cs

@@ -16,6 +16,10 @@ namespace osu.Game.Rulesets.Scoring
         /// <summary>
         /// Indicates that the object has been judged as a miss.
         /// </summary>
+        /// <remarks>
+        /// This miss window should determine how early a hit can be before it is considered for judgement (as opposed to being ignored as
+        /// "too far in the future). It should also define when a forced miss should be triggered (as a result of no user input in time).
+        /// </remarks>
         [Description(@"Miss")]
         Miss,
 

osu.Game/Rulesets/Scoring/HitWindows.cs

@@ -4,51 +4,61 @@
 using System;
 using System.Collections.Generic;
 using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Scoring;
+using osu.Game.Rulesets.Objects;
 
-namespace osu.Game.Rulesets.Objects
+namespace osu.Game.Rulesets.Scoring
 {
+    /// <summary>
+    /// A structure containing timing data for hit window based gameplay.
+    /// </summary>
     public class HitWindows
     {
-        private static readonly IReadOnlyDictionary<HitResult, (double od0, double od5, double od10)> base_ranges = new Dictionary<HitResult, (double, double, double)>
+        private static readonly DifficultyRange[] base_ranges =
         {
-            { HitResult.Perfect, (44.8, 38.8, 27.8) },
+            new DifficultyRange(HitResult.Perfect, 22.4D, 19.4D, 13.9D),
-            { HitResult.Great, (128, 98, 68) },
+            new DifficultyRange(HitResult.Great, 64, 49, 34),
-            { HitResult.Good, (194, 164, 134) },
+            new DifficultyRange(HitResult.Good, 97, 82, 67),
-            { HitResult.Ok, (254, 224, 194) },
+            new DifficultyRange(HitResult.Ok, 127, 112, 97),
-            { HitResult.Meh, (302, 272, 242) },
+            new DifficultyRange(HitResult.Meh, 151, 136, 121),
-            { HitResult.Miss, (376, 346, 316) },
+            new DifficultyRange(HitResult.Miss, 188, 173, 158),
         };
 
         /// <summary>
         /// Hit window for a <see cref="HitResult.Perfect"/> result.
         /// </summary>
-        public double Perfect { get; protected set; }
+        private double perfect;
 
         /// <summary>
         /// Hit window for a <see cref="HitResult.Great"/> result.
         /// </summary>
-        public double Great { get; protected set; }
+        /// <remarks>
+        /// Note that this value includes both the early and late region.
+        /// </remarks>
+        private double great;
 
         /// <summary>
         /// Hit window for a <see cref="HitResult.Good"/> result.
         /// </summary>
-        public double Good { get; protected set; }
+        private double good;
 
         /// <summary>
         /// Hit window for an <see cref="HitResult.Ok"/> result.
         /// </summary>
-        public double Ok { get; protected set; }
+        private double ok;
 
         /// <summary>
         /// Hit window for a <see cref="HitResult.Meh"/> result.
         /// </summary>
-        public double Meh { get; protected set; }
+        private double meh;
 
         /// <summary>
         /// Hit window for a <see cref="HitResult.Miss"/> result.
         /// </summary>
-        public double Miss { get; protected set; }
+        /// <remarks>
+        /// This miss window should determine how early a hit can be before it is considered for judgement (as opposed to being ignored as
+        /// "too far in the future). It should also define when a forced miss should be triggered (as a result of no user input in time).
+        /// </remarks>
+        private double miss;
 
         /// <summary>
         /// Retrieves the <see cref="HitResult"/> with the largest hit window that produces a successful hit.
@@ -66,15 +76,15 @@ namespace osu.Game.Rulesets.Objects
         }
 
         /// <summary>
-        /// Retrieves a mapping of <see cref="HitResult"/>s to their half window timing for all allowed <see cref="HitResult"/>s.
+        /// Retrieves a mapping of <see cref="HitResult"/>s to their timing windows for all allowed <see cref="HitResult"/>s.
         /// </summary>
         /// <returns></returns>
-        public IEnumerable<(HitResult result, double length)> GetAllAvailableHalfWindows()
+        public IEnumerable<(HitResult result, double length)> GetAllAvailableWindows()
         {
             for (var result = HitResult.Meh; result <= HitResult.Perfect; ++result)
             {
                 if (IsHitResultAllowed(result))
-                    yield return (result, HalfWindowFor(result));
+                    yield return (result, WindowFor(result));
             }
         }
 
@@ -100,14 +110,39 @@ namespace osu.Game.Rulesets.Objects
         /// Sets hit windows with values that correspond to a difficulty parameter.
         /// </summary>
         /// <param name="difficulty">The parameter.</param>
-        public virtual void SetDifficulty(double difficulty)
+        public void SetDifficulty(double difficulty)
         {
-            Perfect = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Perfect]);
+            foreach (var range in GetRanges())
-            Great = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Great]);
+            {
-            Good = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Good]);
+                var value = BeatmapDifficulty.DifficultyRange(difficulty, (range.Min, range.Average, range.Max));
-            Ok = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Ok]);
+
-            Meh = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Meh]);
+                switch (range.Result)
-            Miss = BeatmapDifficulty.DifficultyRange(difficulty, base_ranges[HitResult.Miss]);
+                {
+                    case HitResult.Miss:
+                        miss = value;
+                        break;
+
+                    case HitResult.Meh:
+                        meh = value;
+                        break;
+
+                    case HitResult.Ok:
+                        ok = value;
+                        break;
+
+                    case HitResult.Good:
+                        good = value;
+                        break;
+
+                    case HitResult.Great:
+                        great = value;
+                        break;
+
+                    case HitResult.Perfect:
+                        perfect = value;
+                        break;
+                }
+            }
         }
 
         /// <summary>
@@ -121,7 +156,7 @@ namespace osu.Game.Rulesets.Objects
 
             for (var result = HitResult.Perfect; result >= HitResult.Miss; --result)
             {
-                if (IsHitResultAllowed(result) && timeOffset <= HalfWindowFor(result))
+                if (IsHitResultAllowed(result) && timeOffset <= WindowFor(result))
                     return result;
             }
 
@@ -129,32 +164,32 @@ namespace osu.Game.Rulesets.Objects
         }
 
         /// <summary>
-        /// Retrieves half the hit window for a <see cref="HitResult"/>.
+        /// Retrieves the hit window for a <see cref="HitResult"/>.
-        /// This is useful if the hit window for one half of the hittable range of a <see cref="HitObject"/> is required.
+        /// This is the number of +/- milliseconds allowed for the requested result (so the actual hittable range is double this).
         /// </summary>
         /// <param name="result">The expected <see cref="HitResult"/>.</param>
         /// <returns>One half of the hit window for <paramref name="result"/>.</returns>
-        public double HalfWindowFor(HitResult result)
+        public double WindowFor(HitResult result)
         {
             switch (result)
             {
                 case HitResult.Perfect:
-                    return Perfect / 2;
+                    return perfect;
 
                 case HitResult.Great:
-                    return Great / 2;
+                    return great;
 
                 case HitResult.Good:
-                    return Good / 2;
+                    return good;
 
                 case HitResult.Ok:
-                    return Ok / 2;
+                    return ok;
 
                 case HitResult.Meh:
-                    return Meh / 2;
+                    return meh;
 
                 case HitResult.Miss:
-                    return Miss / 2;
+                    return miss;
 
                 default:
                     throw new ArgumentException(nameof(result));
@@ -167,6 +202,30 @@ namespace osu.Game.Rulesets.Objects
         /// </summary>
         /// <param name="timeOffset">The time offset.</param>
         /// <returns>Whether the <see cref="HitObject"/> can be hit at any point in the future from this time offset.</returns>
-        public bool CanBeHit(double timeOffset) => timeOffset <= HalfWindowFor(LowestSuccessfulHitResult());
+        public bool CanBeHit(double timeOffset) => timeOffset <= WindowFor(LowestSuccessfulHitResult());
+
+        /// <summary>
+        /// Retrieve a valid list of <see cref="DifficultyRange"/>s representing hit windows.
+        /// Defaults are provided but can be overridden to customise for a ruleset.
+        /// </summary>
+        protected virtual DifficultyRange[] GetRanges() => base_ranges;
+    }
+
+    public struct DifficultyRange
+    {
+        public readonly HitResult Result;
+
+        public double Min;
+        public double Average;
+        public double Max;
+
+        public DifficultyRange(HitResult result, double min, double average, double max)
+        {
+            Result = result;
+
+            Min = min;
+            Average = average;
+            Max = max;
+        }
     }
 }

osu.Game/Scoring/ScoreInfo.cs

@@ -11,8 +11,8 @@ using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
-using osu.Game.Users;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Users;
 
 namespace osu.Game.Scoring
 {

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

@@ -8,7 +8,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Play.HUD.HitErrorMeters;
 

osu.Game/Screens/Play/HUD/HitErrorMeters/BarHitErrorMeter.cs

@@ -11,7 +11,6 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osuTK;
 using osuTK.Graphics;
@@ -146,7 +145,7 @@ namespace osu.Game.Screens.Play.HUD.HitErrorMeters
 
         private void createColourBars(OsuColour colours)
         {
-            var windows = HitWindows.GetAllAvailableHalfWindows().ToArray();
+            var windows = HitWindows.GetAllAvailableWindows().ToArray();
 
             maxHitWindow = windows.First().length;
 

osu.Game/Screens/Play/HUD/HitErrorMeters/HitErrorMeter.cs

@@ -3,7 +3,7 @@
 
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Screens.Play.HUD.HitErrorMeters
 {