From ee1c3d42d884167d1657027ca9dad17704df7231 Mon Sep 17 00:00:00 2001
From: iiSaLMaN <slmanarendo1950@gmail.com>
Date: Tue, 20 Aug 2019 21:11:26 +0300
Subject: [PATCH 01/27] Add spinner tick judgement

---
 .../Judgements/OsuSpinnerTickJudgement.cs      | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 osu.Game.Rulesets.Osu/Judgements/OsuSpinnerTickJudgement.cs

diff --git a/osu.Game.Rulesets.Osu/Judgements/OsuSpinnerTickJudgement.cs b/osu.Game.Rulesets.Osu/Judgements/OsuSpinnerTickJudgement.cs
new file mode 100644
index 0000000000..f9cac7a2c1
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Judgements/OsuSpinnerTickJudgement.cs
@@ -0,0 +1,18 @@
+// 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.Judgements
+{
+    public class OsuSpinnerTickJudgement : OsuJudgement
+    {
+        internal bool HasBonusPoints;
+
+        public override bool AffectsCombo => false;
+
+        protected override int NumericResultFor(HitResult result) => 100 + (HasBonusPoints ? 1000 : 0);
+
+        protected override double HealthIncreaseFor(HitResult result) => 0;
+    }
+}

From bb4178fa037a2b9a4d361b7a89715958d773db3e Mon Sep 17 00:00:00 2001
From: iiSaLMaN <slmanarendo1950@gmail.com>
Date: Tue, 20 Aug 2019 21:17:27 +0300
Subject: [PATCH 02/27] Add drawable spinner ticks implementation

---
 .../Objects/Drawables/DrawableSpinnerTick.cs  | 49 +++++++++++++++++++
 osu.Game.Rulesets.Osu/Objects/Spinner.cs      | 11 +++++
 osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs  | 19 +++++++
 .../Replays/OsuAutoGeneratorBase.cs           |  2 +-
 4 files changed, 80 insertions(+), 1 deletion(-)
 create mode 100644 osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
 create mode 100644 osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
new file mode 100644
index 0000000000..9c316591a9
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
@@ -0,0 +1,49 @@
+// 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.Audio;
+using osu.Framework.Bindables;
+using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class DrawableSpinnerTick : DrawableOsuHitObject
+    {
+        private readonly BindableDouble bonusSampleVolume = new BindableDouble();
+
+        private bool hasBonusPoints;
+
+        /// <summary>
+        /// Whether this judgement has a bonus of 1,000 points additional to the numeric result.
+        /// Should be set when a spin occured after the spinner has completed.
+        /// </summary>
+        public bool HasBonusPoints
+        {
+            get => hasBonusPoints;
+            internal set
+            {
+                hasBonusPoints = value;
+
+                bonusSampleVolume.Value = value ? 1 : 0;
+                ((OsuSpinnerTickJudgement)Result.Judgement).HasBonusPoints = value;
+            }
+        }
+
+        public override bool DisplayResult => false;
+
+        public DrawableSpinnerTick(SpinnerTick spinnerTick)
+            : base(spinnerTick)
+        {
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Samples.AddAdjustment(AdjustableProperty.Volume, bonusSampleVolume);
+        }
+
+        public void TriggerResult(HitResult result) => ApplyResult(r => r.Type = result);
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/Objects/Spinner.cs b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
index 8a2fd3b7aa..c32ec7be1c 100644
--- a/osu.Game.Rulesets.Osu/Objects/Spinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
@@ -7,6 +7,8 @@ using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Osu.Replays;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -30,6 +32,15 @@ namespace osu.Game.Rulesets.Osu.Objects
             SpinsRequired = (int)Math.Max(1, SpinsRequired * 0.6);
         }
 
+        protected override void CreateNestedHitObjects()
+        {
+            base.CreateNestedHitObjects();
+
+            var maximumSpins = OsuAutoGeneratorBase.SPIN_RADIUS * (Duration / 1000) / MathHelper.TwoPi;
+            for (int i = 0; i < maximumSpins; i++)
+                AddNested(new SpinnerTick());
+        }
+
         public override Judgement CreateJudgement() => new OsuJudgement();
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
new file mode 100644
index 0000000000..18a3dc771b
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Objects/SpinnerTick.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.Audio;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu.Judgements;
+
+namespace osu.Game.Rulesets.Osu.Objects
+{
+    public class SpinnerTick : OsuHitObject
+    {
+        public SpinnerTick()
+        {
+            Samples.Add(new HitSampleInfo { Name = "spinnerbonus" });
+        }
+
+        public override Judgement CreateJudgement() => new OsuSpinnerTickJudgement();
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs b/osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs
index 9ab358ee12..3356a0fbe0 100644
--- a/osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs
+++ b/osu.Game.Rulesets.Osu/Replays/OsuAutoGeneratorBase.cs
@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Replays
         /// </summary>
         protected static readonly Vector2 SPINNER_CENTRE = OsuPlayfield.BASE_SIZE / 2;
 
-        protected const float SPIN_RADIUS = 50;
+        public const float SPIN_RADIUS = 50;
 
         /// <summary>
         /// The time in ms between each ReplayFrame.

From 07795c9922cc4b3ce5197010b03fc53e0b1f565b Mon Sep 17 00:00:00 2001
From: iiSaLMaN <slmanarendo1950@gmail.com>
Date: Tue, 20 Aug 2019 21:50:49 +0300
Subject: [PATCH 03/27] Add logic to gain bonus score from spinner ticks

---
 .../Objects/Drawables/DrawableSpinner.cs      | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index a0bd301fdb..d166d6b845 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -12,7 +12,9 @@ using osu.Game.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Screens.Ranking;
 using osu.Game.Rulesets.Scoring;
 
@@ -22,6 +24,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
     {
         protected readonly Spinner Spinner;
 
+        private readonly Container<DrawableSpinnerTick> ticks;
+        private readonly OsuSpriteText bonusCounter;
+
         public readonly SpinnerDisc Disc;
         public readonly SpinnerTicks Ticks;
         private readonly SpinnerSpmCounter spmCounter;
@@ -58,6 +63,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             InternalChildren = new Drawable[]
             {
+                ticks = new Container<DrawableSpinnerTick>(),
                 circleContainer = new Container
                 {
                     AutoSizeAxes = Axes.Both,
@@ -115,8 +121,24 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Origin = Anchor.Centre,
                     Y = 120,
                     Alpha = 0
+                },
+                bonusCounter = new OsuSpriteText
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Y = -120,
+                    Font = OsuFont.Numeric.With(size: 24),
+                    Alpha = 0,
                 }
             };
+
+            foreach (var tick in Spinner.NestedHitObjects.OfType<SpinnerTick>())
+            {
+                var drawableTick = new DrawableSpinnerTick(tick);
+
+                ticks.Add(drawableTick);
+                AddNested(drawableTick);
+            }
         }
 
         [BackgroundDependencyLoader]
@@ -182,6 +204,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             base.Update();
         }
 
+        private int currentSpins;
+
         protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();
@@ -190,6 +214,22 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Ticks.Rotation = Disc.Rotation;
             spmCounter.SetRotation(Disc.RotationAbsolute);
 
+            var newSpins = (int)(Disc.RotationAbsolute / 360) - currentSpins;
+
+            for (int i = currentSpins; i < currentSpins + newSpins; i++)
+            {
+                if (i < 0 || i >= ticks.Count)
+                    break;
+
+                var tick = ticks[i];
+
+                tick.HasBonusPoints = Progress >= 1 && i > Spinner.SpinsRequired;
+
+                tick.TriggerResult(HitResult.Great);
+            }
+
+            currentSpins += newSpins;
+
             float relativeCircleScale = Spinner.Scale * circle.DrawHeight / mainContainer.DrawHeight;
             Disc.ScaleTo(relativeCircleScale + (1 - relativeCircleScale) * Progress, 200, Easing.OutQuint);
 
@@ -232,6 +272,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     break;
             }
 
+            if (state != ArmedState.Idle)
+                Schedule(() => NestedHitObjects.Where(t => !t.IsHit).OfType<DrawableSpinnerTick>().ForEach(t => t.TriggerResult(HitResult.Miss)));
+
             Expire();
         }
     }

From e4179fe4403232aa5663c80c7ee21800a20bd204 Mon Sep 17 00:00:00 2001
From: iiSaLMaN <slmanarendo1950@gmail.com>
Date: Tue, 20 Aug 2019 21:51:32 +0300
Subject: [PATCH 04/27] Show bonus text if contains bonus points (1,000)

---
 osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index d166d6b845..b97f4e0a57 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -225,6 +225,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
                 tick.HasBonusPoints = Progress >= 1 && i > Spinner.SpinsRequired;
 
+                if (tick.HasBonusPoints)
+                    bonusCounter
+                        .TransformTextTo($"{(i - Spinner.SpinsRequired) * 1000}")
+                        .FadeOutFromOne(1500)
+                        .ScaleTo(1.5f).ScaleTo(1f, 1000, Easing.OutQuint);
+
                 tick.TriggerResult(HitResult.Great);
             }
 

From dbf4884cbc64c736b16d334a2ed29e3f7780ce5b Mon Sep 17 00:00:00 2001
From: iiSaLMaN <slmanarendo1950@gmail.com>
Date: Tue, 20 Aug 2019 21:52:13 +0300
Subject: [PATCH 05/27] Adjust test spinner rotation

---
 osu.Game.Rulesets.Osu.Tests/TestSceneSpinner.cs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinner.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinner.cs
index 3ed3f3e981..6e0745d125 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinner.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinner.cs
@@ -64,7 +64,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private class TestDrawableSpinner : DrawableSpinner
         {
-            private bool auto;
+            private readonly bool auto;
 
             public TestDrawableSpinner(Spinner s, bool auto)
                 : base(s)
@@ -74,12 +74,8 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             protected override void CheckForResult(bool userTriggered, double timeOffset)
             {
-                if (auto && !userTriggered && Time.Current > Spinner.StartTime + Spinner.Duration / 2 && Progress < 1)
-                {
-                    // force completion only once to not break human interaction
-                    Disc.RotationAbsolute = Spinner.SpinsRequired * 360;
-                    auto = false;
-                }
+                if (auto && !userTriggered && Time.Current > Spinner.StartTime)
+                    Disc.RotationAbsolute += Progress >= 1 ? 10 : (float)(Spinner.Duration / 120);
 
                 base.CheckForResult(userTriggered, timeOffset);
             }

From 6b7cb46ddaf9518e9f876535a86f385ed0db1a26 Mon Sep 17 00:00:00 2001
From: iiSaLMaN <slmanarendo1950@gmail.com>
Date: Sat, 7 Sep 2019 17:27:02 +0300
Subject: [PATCH 06/27] Add null hit windows

---
 osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
index 18a3dc771b..c2104e68ee 100644
--- a/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
@@ -4,6 +4,7 @@
 using osu.Game.Audio;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
+using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -15,5 +16,7 @@ namespace osu.Game.Rulesets.Osu.Objects
         }
 
         public override Judgement CreateJudgement() => new OsuSpinnerTickJudgement();
+
+        protected override HitWindows CreateHitWindows() => null;
     }
 }

From 33f4a6897cd315ba7e3790378a586a9adf424b1d Mon Sep 17 00:00:00 2001
From: iiSaLMaN <slmanarendo1950@gmail.com>
Date: Sat, 7 Sep 2019 18:01:15 +0300
Subject: [PATCH 07/27] Assign to the text property directly

---
 osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index fc1e410d5f..62cec0f124 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -226,10 +226,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 tick.HasBonusPoints = Progress >= 1 && i > Spinner.SpinsRequired;
 
                 if (tick.HasBonusPoints)
+                {
+                    bonusCounter.Text = $"{(i - Spinner.SpinsRequired) * 1000}";
                     bonusCounter
-                        .TransformTextTo($"{(i - Spinner.SpinsRequired) * 1000}")
                         .FadeOutFromOne(1500)
                         .ScaleTo(1.5f).ScaleTo(1f, 1000, Easing.OutQuint);
+                }
 
                 tick.TriggerResult(HitResult.Great);
             }

From 5d2fe8733997295bbbecee0cdbc947440e305d06 Mon Sep 17 00:00:00 2001
From: iiSaLMaN <slmanarendo1950@gmail.com>
Date: Mon, 14 Oct 2019 00:38:45 +0300
Subject: [PATCH 08/27] Use empty hit windows for spinner ticks

---
 osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
index c2104e68ee..318e8e71a2 100644
--- a/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
@@ -17,6 +17,6 @@ namespace osu.Game.Rulesets.Osu.Objects
 
         public override Judgement CreateJudgement() => new OsuSpinnerTickJudgement();
 
-        protected override HitWindows CreateHitWindows() => null;
+        protected override HitWindows CreateHitWindows() => HitWindows.Empty;
     }
 }

From 68e370ce7cd72c51a7eda6f9863ed37b0f86b3d5 Mon Sep 17 00:00:00 2001
From: iiSaLMaN <slmanarendo1950@gmail.com>
Date: Mon, 14 Oct 2019 00:39:20 +0300
Subject: [PATCH 09/27] Set spinner tick start time to allow result reverting

---
 .../Objects/Drawables/DrawableSpinnerTick.cs                | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
index 9c316591a9..21cf7b3acb 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
@@ -44,6 +44,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Samples.AddAdjustment(AdjustableProperty.Volume, bonusSampleVolume);
         }
 
-        public void TriggerResult(HitResult result) => ApplyResult(r => r.Type = result);
+        public void TriggerResult(HitResult result)
+        {
+            HitObject.StartTime = Time.Current;
+            ApplyResult(r => r.Type = result);
+        }
     }
 }

From a75ae14cb20efca1673d863001736361c29c07f8 Mon Sep 17 00:00:00 2001
From: iiSaLMaN <slmanarendo1950@gmail.com>
Date: Mon, 14 Oct 2019 00:40:36 +0300
Subject: [PATCH 10/27] Use foreach loop to avoid too long lines

---
 .../Objects/Drawables/DrawableSpinner.cs                 | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index 08e64b7ecf..965303ba7a 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -12,7 +12,6 @@ using osu.Game.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Scoring;
@@ -279,7 +278,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
 
             if (state != ArmedState.Idle)
-                Schedule(() => NestedHitObjects.Where(t => !t.IsHit).OfType<DrawableSpinnerTick>().ForEach(t => t.TriggerResult(HitResult.Miss)));
+            {
+                Schedule(() =>
+                {
+                    foreach (var tick in ticks.Where(t => !t.IsHit))
+                        tick.TriggerResult(HitResult.Miss);
+                });
+            }
         }
     }
 }

From a8514ecd0f220f39c214e13cd89409f1a6694c3e Mon Sep 17 00:00:00 2001
From: iiSaLMaN <slmanarendo1950@gmail.com>
Date: Mon, 14 Oct 2019 00:43:46 +0300
Subject: [PATCH 11/27] Add tests ensuring correct spinner ticks score results

---
 .../TestSceneSpinnerRotation.cs               | 45 ++++++++++++++++---
 1 file changed, 40 insertions(+), 5 deletions(-)

diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs
index cded7f0e95..b03788a7d6 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs
@@ -15,6 +15,8 @@ using osu.Game.Tests.Visual;
 using osuTK;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play;
 using static osu.Game.Tests.Visual.OsuTestScene.ClockBackedTestWorkingBeatmap;
 
 namespace osu.Game.Rulesets.Osu.Tests
@@ -28,6 +30,8 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         protected override bool Autoplay => true;
 
+        protected override Player CreatePlayer(Ruleset ruleset) => new ScoreExposedPlayer();
+
         protected override WorkingBeatmap CreateWorkingBeatmap(IBeatmap beatmap)
         {
             var working = new ClockBackedTestWorkingBeatmap(beatmap, new FramedClock(new ManualClock { Rate = 1 }), audioManager);
@@ -69,6 +73,32 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("is rotation absolute almost same", () => Precision.AlmostEquals(drawableSpinner.Disc.RotationAbsolute, estimatedRotation, 100));
         }
 
+        [Test]
+        public void TestSpinnerNormalBonusRewinding()
+        {
+            addSeekStep(1000);
+
+            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;
+                return totalScore == (int)(drawableSpinner.Disc.RotationAbsolute / 360) * 100;
+            });
+
+            addSeekStep(0);
+
+            AddAssert("player score is 0", () => ((ScoreExposedPlayer)Player).ScoreProcessor.TotalScore.Value == 0);
+        }
+
+        [Test]
+        public void TestSpinnerCompleteBonusRewinding()
+        {
+            addSeekStep(2500);
+            addSeekStep(0);
+
+            AddAssert("player score is 0", () => ((ScoreExposedPlayer)Player).ScoreProcessor.TotalScore.Value == 0);
+        }
+
         private void addSeekStep(double time)
         {
             AddStep($"seek to {time}", () => track.Seek(time));
@@ -85,12 +115,17 @@ namespace osu.Game.Rulesets.Osu.Tests
                     Position = new Vector2(256, 192),
                     EndTime = 5000,
                 },
-                // placeholder object to avoid hitting the results screen
-                new HitObject
-                {
-                    StartTime = 99999,
-                }
             }
         };
+
+        private class ScoreExposedPlayer : TestPlayer
+        {
+            public new ScoreProcessor ScoreProcessor => base.ScoreProcessor;
+
+            public ScoreExposedPlayer()
+                : base(false, false)
+            {
+            }
+        }
     }
 }

From 10e1e512fd45abf199bea01c8d70ebfa2337df4c Mon Sep 17 00:00:00 2001
From: Salman Ahmed <email@iisalman.me>
Date: Thu, 12 Dec 2019 15:15:16 +0300
Subject: [PATCH 12/27] Update the nested hitobject logic inline with new
 implementation

---
 .../Objects/Drawables/DrawableSpinner.cs      | 32 ++++++++++++++++---
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index 39330f08c3..2c21b4244a 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -15,6 +15,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Ranking;
 
@@ -131,16 +132,37 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Alpha = 0,
                 }
             };
+        }
 
-            foreach (var tick in Spinner.NestedHitObjects.OfType<SpinnerTick>())
+        protected override void AddNestedHitObject(DrawableHitObject hitObject)
+        {
+            base.AddNestedHitObject(hitObject);
+
+            switch (hitObject)
             {
-                var drawableTick = new DrawableSpinnerTick(tick);
-
-                ticks.Add(drawableTick);
-                AddNestedHitObject(drawableTick);
+                case DrawableSpinnerTick tick:
+                    ticks.Add(tick);
+                    break;
             }
         }
 
+        protected override void ClearNestedHitObjects()
+        {
+            base.ClearNestedHitObjects();
+            ticks.Clear();
+        }
+
+        protected override DrawableHitObject CreateNestedHitObject(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case SpinnerTick tick:
+                    return new DrawableSpinnerTick(tick);
+            }
+
+            return base.CreateNestedHitObject(hitObject);
+        }
+
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {

From 949ab4e0d3889e4ea88850b49715c1e3f8cc46d2 Mon Sep 17 00:00:00 2001
From: Salman Ahmed <email@iisalman.me>
Date: Wed, 25 Dec 2019 05:34:12 +0300
Subject: [PATCH 13/27] Move spinner bonus scoring to it's own component class

Also fixes counter rewinding issue and does optimizations.
---
 .../Objects/Drawables/DrawableSpinner.cs      | 42 +--------
 .../Objects/Drawables/DrawableSpinnerTick.cs  | 10 ++-
 .../Drawables/Pieces/SpinnerBonusComponent.cs | 90 +++++++++++++++++++
 3 files changed, 100 insertions(+), 42 deletions(-)
 create mode 100644 osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index f7f4275d2a..86e8840425 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -26,11 +26,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected readonly Spinner Spinner;
 
         private readonly Container<DrawableSpinnerTick> ticks;
-        private readonly OsuSpriteText bonusCounter;
 
         public readonly SpinnerDisc Disc;
         public readonly SpinnerTicks Ticks;
         public readonly SpinnerSpmCounter SpmCounter;
+        private readonly SpinnerBonusComponent bonusComponent;
 
         private readonly Container mainContainer;
 
@@ -123,13 +123,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Y = 120,
                     Alpha = 0
                 },
-                bonusCounter = new OsuSpriteText
+                bonusComponent = new SpinnerBonusComponent(this, ticks)
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
                     Y = -120,
-                    Font = OsuFont.Numeric.With(size: 24),
-                    Alpha = 0,
                 }
             };
         }
@@ -226,8 +224,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             base.Update();
         }
 
-        private int currentSpins;
-
         protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();
@@ -235,30 +231,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             circle.Rotation = Disc.Rotation;
             Ticks.Rotation = Disc.Rotation;
             SpmCounter.SetRotation(Disc.RotationAbsolute);
-
-            var newSpins = (int)(Disc.RotationAbsolute / 360) - currentSpins;
-
-            for (int i = currentSpins; i < currentSpins + newSpins; i++)
-            {
-                if (i < 0 || i >= ticks.Count)
-                    break;
-
-                var tick = ticks[i];
-
-                tick.HasBonusPoints = Progress >= 1 && i > Spinner.SpinsRequired;
-
-                if (tick.HasBonusPoints)
-                {
-                    bonusCounter.Text = $"{(i - Spinner.SpinsRequired) * 1000}";
-                    bonusCounter
-                        .FadeOutFromOne(1500)
-                        .ScaleTo(1.5f).ScaleTo(1f, 1000, Easing.OutQuint);
-                }
-
-                tick.TriggerResult(HitResult.Great);
-            }
-
-            currentSpins += newSpins;
+            bonusComponent.UpdateRotation(Disc.RotationAbsolute);
 
             float relativeCircleScale = Spinner.Scale * circle.DrawHeight / mainContainer.DrawHeight;
             Disc.ScaleTo(relativeCircleScale + (1 - relativeCircleScale) * Progress, 200, Easing.OutQuint);
@@ -299,15 +272,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     sequence.ScaleTo(Scale * 0.8f, 320, Easing.In);
                     break;
             }
-
-            if (state != ArmedState.Idle)
-            {
-                Schedule(() =>
-                {
-                    foreach (var tick in ticks.Where(t => !t.IsHit))
-                        tick.TriggerResult(HitResult.Miss);
-                });
-            }
         }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
index 21cf7b3acb..6512a9526e 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         /// <summary>
         /// Whether this judgement has a bonus of 1,000 points additional to the numeric result.
-        /// Should be set when a spin occured after the spinner has completed.
+        /// Set when a spin occured after the spinner has completed.
         /// </summary>
         public bool HasBonusPoints
         {
@@ -44,10 +44,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Samples.AddAdjustment(AdjustableProperty.Volume, bonusSampleVolume);
         }
 
-        public void TriggerResult(HitResult result)
+        /// <summary>
+        /// Apply a judgement result.
+        /// </summary>
+        /// <param name="hit">Whether to apply a <see cref="HitResult.Great"/> result, <see cref="HitResult.Miss"/> otherwise.</param>
+        internal void TriggerResult(bool hit)
         {
             HitObject.StartTime = Time.Current;
-            ApplyResult(r => r.Type = result);
+            ApplyResult(r => r.Type = hit ? HitResult.Great : HitResult.Miss);
         }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs
new file mode 100644
index 0000000000..5c96751b3a
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs
@@ -0,0 +1,90 @@
+// 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 osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    /// <summary>
+    /// A component that tracks spinner spins and add bonus score for it.
+    /// </summary>
+    public class SpinnerBonusComponent : CompositeDrawable
+    {
+        private readonly DrawableSpinner drawableSpinner;
+        private readonly Container<DrawableSpinnerTick> ticks;
+        private readonly OsuSpriteText bonusCounter;
+
+        public SpinnerBonusComponent(DrawableSpinner drawableSpinner, Container<DrawableSpinnerTick> ticks)
+        {
+            this.drawableSpinner = drawableSpinner;
+            this.ticks = ticks;
+
+            drawableSpinner.OnNewResult += onNewResult;
+
+            AutoSizeAxes = Axes.Both;
+            InternalChild = bonusCounter = new OsuSpriteText
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Font = OsuFont.Numeric.With(size: 24),
+                Alpha = 0,
+            };
+        }
+
+        private int currentSpins;
+
+        public void UpdateRotation(double rotation)
+        {
+            if (ticks.Count == 0)
+                return;
+
+            int spinsRequired = ((Spinner)drawableSpinner.HitObject).SpinsRequired;
+
+            int newSpins = Math.Clamp((int)(rotation / 360), 0, ticks.Count - 1);
+            int direction = Math.Sign(newSpins - currentSpins);
+
+            while (currentSpins != newSpins)
+            {
+                var tick = ticks[currentSpins];
+
+                if (direction >= 0)
+                {
+                    tick.HasBonusPoints = currentSpins > spinsRequired;
+                    tick.TriggerResult(true);
+                }
+
+                if (tick.HasBonusPoints)
+                {
+                    bonusCounter.Text = $"{1000 * (currentSpins - spinsRequired)}";
+                    bonusCounter.FadeOutFromOne(1500);
+                    bonusCounter.ScaleTo(1.5f).Then().ScaleTo(1f, 1000, Easing.OutQuint);
+                }
+
+                currentSpins += direction;
+            }
+        }
+
+        private void onNewResult(DrawableHitObject hitObject, JudgementResult result)
+        {
+            if (!result.HasResult || hitObject != drawableSpinner)
+                return;
+
+            // Trigger a miss result for remaining ticks to avoid infinite gameplay.
+            foreach (var tick in ticks.Where(t => !t.IsHit))
+                tick.TriggerResult(false);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            drawableSpinner.OnNewResult -= onNewResult;
+        }
+    }
+}

From b7565f5943f05247b6469491f052dd6287c95db3 Mon Sep 17 00:00:00 2001
From: Salman Ahmed <email@iisalman.me>
Date: Wed, 25 Dec 2019 05:36:58 +0300
Subject: [PATCH 14/27] Remove unnecessary using directive

---
 osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index 86e8840425..edcaa947ac 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -14,7 +14,6 @@ using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Screens.Ranking;

From f48984920d5b489adba4afd4a8c3c9fedaceebe1 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Tue, 21 Jul 2020 11:21:32 +0900
Subject: [PATCH 15/27] Change bonus volume logic to work

---
 .../Objects/Drawables/DrawableSpinnerTick.cs       | 14 +-------------
 1 file changed, 1 insertion(+), 13 deletions(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
index 6512a9526e..436994e480 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
@@ -1,8 +1,6 @@
 // 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.Audio;
-using osu.Framework.Bindables;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 
@@ -10,8 +8,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableSpinnerTick : DrawableOsuHitObject
     {
-        private readonly BindableDouble bonusSampleVolume = new BindableDouble();
-
         private bool hasBonusPoints;
 
         /// <summary>
@@ -25,8 +21,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             {
                 hasBonusPoints = value;
 
-                bonusSampleVolume.Value = value ? 1 : 0;
-                ((OsuSpinnerTickJudgement)Result.Judgement).HasBonusPoints = value;
+                Samples.Volume.Value = ((OsuSpinnerTickJudgement)Result.Judgement).HasBonusPoints ? 1 : 0;
             }
         }
 
@@ -37,13 +32,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            Samples.AddAdjustment(AdjustableProperty.Volume, bonusSampleVolume);
-        }
-
         /// <summary>
         /// Apply a judgement result.
         /// </summary>

From 4dd40542d519ad2f5db5a529ec864b990a0ec697 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Tue, 21 Jul 2020 11:21:58 +0900
Subject: [PATCH 16/27] Rename rotation set method to match others

---
 osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs      | 2 +-
 .../Objects/Drawables/Pieces/SpinnerBonusComponent.cs           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index b82b44f35b..2707453ab9 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -227,7 +227,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Ticks.Rotation = Disc.Rotation;
 
             SpmCounter.SetRotation(Disc.CumulativeRotation);
-            bonusComponent.UpdateRotation(Disc.CumulativeRotation);
+            bonusComponent.SetRotation(Disc.CumulativeRotation);
 
             float relativeCircleScale = Spinner.Scale * circle.DrawHeight / mainContainer.DrawHeight;
             float targetScale = relativeCircleScale + (1 - relativeCircleScale) * Progress;
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs
index 5c96751b3a..c49c10b45c 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs
@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
         private int currentSpins;
 
-        public void UpdateRotation(double rotation)
+        public void SetRotation(double rotation)
         {
             if (ticks.Count == 0)
                 return;

From 35ad409da6fd60f48f66b58003058ac9d2c5b360 Mon Sep 17 00:00:00 2001
From: Salman Ahmed <email@iisalman.me>
Date: Tue, 21 Jul 2020 06:59:24 +0300
Subject: [PATCH 17/27] Fix spinner bonus ticks samples not actually playing

---
 osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
index 436994e480..d49766adda 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
@@ -21,7 +21,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             {
                 hasBonusPoints = value;
 
-                Samples.Volume.Value = ((OsuSpinnerTickJudgement)Result.Judgement).HasBonusPoints ? 1 : 0;
+                ((OsuSpinnerTickJudgement)Result.Judgement).HasBonusPoints = value;
+                Samples.Volume.Value = value ? 1 : 0;
             }
         }
 

From 05102bc1baf00b4508bf57dfe0e749569944b8ec Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Tue, 21 Jul 2020 18:22:37 +0900
Subject: [PATCH 18/27] Split ticks up into bonus and non-bonus

---
 .../Judgements/OsuSpinnerTickJudgement.cs     | 18 --------------
 .../Objects/Drawables/DrawableSpinner.cs      |  3 +++
 .../Drawables/DrawableSpinnerBonusTick.cs     | 13 ++++++++++
 .../Objects/Drawables/DrawableSpinnerTick.cs  | 19 ---------------
 .../Drawables/Pieces/SpinnerBonusComponent.cs |  5 +---
 osu.Game.Rulesets.Osu/Objects/Spinner.cs      | 19 ++++++++++-----
 .../Objects/SpinnerBonusTick.cs               | 24 +++++++++++++++++++
 osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs  | 15 +++++++-----
 8 files changed, 63 insertions(+), 53 deletions(-)
 delete mode 100644 osu.Game.Rulesets.Osu/Judgements/OsuSpinnerTickJudgement.cs
 create mode 100644 osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerBonusTick.cs
 create mode 100644 osu.Game.Rulesets.Osu/Objects/SpinnerBonusTick.cs

diff --git a/osu.Game.Rulesets.Osu/Judgements/OsuSpinnerTickJudgement.cs b/osu.Game.Rulesets.Osu/Judgements/OsuSpinnerTickJudgement.cs
deleted file mode 100644
index f9cac7a2c1..0000000000
--- a/osu.Game.Rulesets.Osu/Judgements/OsuSpinnerTickJudgement.cs
+++ /dev/null
@@ -1,18 +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.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Osu.Judgements
-{
-    public class OsuSpinnerTickJudgement : OsuJudgement
-    {
-        internal bool HasBonusPoints;
-
-        public override bool AffectsCombo => false;
-
-        protected override int NumericResultFor(HitResult result) => 100 + (HasBonusPoints ? 1000 : 0);
-
-        protected override double HealthIncreaseFor(HitResult result) => 0;
-    }
-}
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index 2707453ab9..531d16d1d1 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -157,6 +157,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             switch (hitObject)
             {
+                case SpinnerBonusTick bonusTick:
+                    return new DrawableSpinnerBonusTick(bonusTick);
+
                 case SpinnerTick tick:
                     return new DrawableSpinnerTick(tick);
             }
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerBonusTick.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerBonusTick.cs
new file mode 100644
index 0000000000..2e1c07c4c6
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerBonusTick.cs
@@ -0,0 +1,13 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class DrawableSpinnerBonusTick : DrawableSpinnerTick
+    {
+        public DrawableSpinnerBonusTick(SpinnerBonusTick spinnerTick)
+            : base(spinnerTick)
+        {
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
index d49766adda..5fb7653f5a 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
@@ -1,31 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
     public class DrawableSpinnerTick : DrawableOsuHitObject
     {
-        private bool hasBonusPoints;
-
-        /// <summary>
-        /// Whether this judgement has a bonus of 1,000 points additional to the numeric result.
-        /// Set when a spin occured after the spinner has completed.
-        /// </summary>
-        public bool HasBonusPoints
-        {
-            get => hasBonusPoints;
-            internal set
-            {
-                hasBonusPoints = value;
-
-                ((OsuSpinnerTickJudgement)Result.Judgement).HasBonusPoints = value;
-                Samples.Volume.Value = value ? 1 : 0;
-            }
-        }
-
         public override bool DisplayResult => false;
 
         public DrawableSpinnerTick(SpinnerTick spinnerTick)
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs
index c49c10b45c..9a65247453 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs
@@ -55,12 +55,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                 var tick = ticks[currentSpins];
 
                 if (direction >= 0)
-                {
-                    tick.HasBonusPoints = currentSpins > spinsRequired;
                     tick.TriggerResult(true);
-                }
 
-                if (tick.HasBonusPoints)
+                if (tick is DrawableSpinnerBonusTick)
                 {
                     bonusCounter.Text = $"{1000 * (currentSpins - spinsRequired)}";
                     bonusCounter.FadeOutFromOne(1500);
diff --git a/osu.Game.Rulesets.Osu/Objects/Spinner.cs b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
index 4c21d9cfde..1c30058d5d 100644
--- a/osu.Game.Rulesets.Osu/Objects/Spinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
@@ -3,13 +3,11 @@
 
 using System;
 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.Types;
 using osu.Game.Rulesets.Osu.Judgements;
-using osu.Game.Rulesets.Osu.Replays;
 using osu.Game.Rulesets.Scoring;
-using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -28,6 +26,8 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         public int SpinsRequired { get; protected set; } = 1;
 
+        public int MaximumBonusSpins => SpinsRequired;
+
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
@@ -42,9 +42,16 @@ namespace osu.Game.Rulesets.Osu.Objects
         {
             base.CreateNestedHitObjects();
 
-            var maximumSpins = OsuAutoGeneratorBase.SPIN_RADIUS * (Duration / 1000) / MathHelper.TwoPi;
-            for (int i = 0; i < maximumSpins; i++)
-                AddNested(new SpinnerTick());
+            int totalSpins = MaximumBonusSpins + SpinsRequired;
+
+            for (int i = 0; i < totalSpins; i++)
+            {
+                double startTime = StartTime + (float)(i + 1) / totalSpins * Duration;
+
+                AddNested(i < SpinsRequired
+                    ? new SpinnerTick { StartTime = startTime }
+                    : new SpinnerBonusTick { StartTime = startTime });
+            }
         }
 
         public override Judgement CreateJudgement() => new OsuJudgement();
diff --git a/osu.Game.Rulesets.Osu/Objects/SpinnerBonusTick.cs b/osu.Game.Rulesets.Osu/Objects/SpinnerBonusTick.cs
new file mode 100644
index 0000000000..84eb58c70b
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Objects/SpinnerBonusTick.cs
@@ -0,0 +1,24 @@
+// 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.Audio;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Osu.Objects
+{
+    public class SpinnerBonusTick : SpinnerTick
+    {
+        public SpinnerBonusTick()
+        {
+            Samples.Add(new HitSampleInfo { Name = "spinnerbonus" });
+        }
+
+        public override Judgement CreateJudgement() => new OsuSpinnerBonusTickJudgement();
+
+        public class OsuSpinnerBonusTickJudgement : OsuSpinnerTickJudgement
+        {
+            protected override int NumericResultFor(HitResult result) => 1100;
+        }
+    }
+}
diff --git a/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
index 318e8e71a2..89ad45b267 100644
--- a/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
@@ -1,7 +1,6 @@
 // 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.Audio;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
@@ -10,13 +9,17 @@ namespace osu.Game.Rulesets.Osu.Objects
 {
     public class SpinnerTick : OsuHitObject
     {
-        public SpinnerTick()
-        {
-            Samples.Add(new HitSampleInfo { Name = "spinnerbonus" });
-        }
-
         public override Judgement CreateJudgement() => new OsuSpinnerTickJudgement();
 
         protected override HitWindows CreateHitWindows() => HitWindows.Empty;
+
+        public class OsuSpinnerTickJudgement : OsuJudgement
+        {
+            public override bool AffectsCombo => false;
+
+            protected override int NumericResultFor(HitResult result) => 100;
+
+            protected override double HealthIncreaseFor(HitResult result) => 0;
+        }
     }
 }

From 947f4e0d4c5aac6609ef6cfdf5488256402c6376 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Tue, 21 Jul 2020 19:03:17 +0900
Subject: [PATCH 19/27] Move tick handling to DrawableSpinner itself

---
 .../Objects/Drawables/DrawableSpinner.cs      | 42 ++++++++-
 .../Objects/Drawables/DrawableSpinnerTick.cs  |  7 +-
 .../Drawables/Pieces/SpinnerBonusComponent.cs | 87 -------------------
 .../Drawables/Pieces/SpinnerBonusDisplay.cs   | 44 ++++++++++
 4 files changed, 86 insertions(+), 94 deletions(-)
 delete mode 100644 osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs
 create mode 100644 osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusDisplay.cs

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index 531d16d1d1..df6eb206da 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -30,7 +30,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         public readonly SpinnerDisc Disc;
         public readonly SpinnerTicks Ticks;
         public readonly SpinnerSpmCounter SpmCounter;
-        private readonly SpinnerBonusComponent bonusComponent;
+        private readonly SpinnerBonusDisplay bonusDisplay;
 
         private readonly Container mainContainer;
 
@@ -126,7 +126,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Y = 120,
                     Alpha = 0
                 },
-                bonusComponent = new SpinnerBonusComponent(this, ticks)
+                bonusDisplay = new SpinnerBonusDisplay
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -199,6 +199,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (userTriggered || Time.Current < Spinner.EndTime)
                 return;
 
+            // Trigger a miss result for remaining ticks to avoid infinite gameplay.
+            foreach (var tick in ticks.Where(t => !t.IsHit))
+                tick.TriggerResult(HitResult.Miss);
+
             ApplyResult(r =>
             {
                 if (Progress >= 1)
@@ -230,7 +234,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Ticks.Rotation = Disc.Rotation;
 
             SpmCounter.SetRotation(Disc.CumulativeRotation);
-            bonusComponent.SetRotation(Disc.CumulativeRotation);
+
+            updateBonusScore();
 
             float relativeCircleScale = Spinner.Scale * circle.DrawHeight / mainContainer.DrawHeight;
             float targetScale = relativeCircleScale + (1 - relativeCircleScale) * Progress;
@@ -239,6 +244,37 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             symbol.Rotation = (float)Interpolation.Lerp(symbol.Rotation, Disc.Rotation / 2, Math.Clamp(Math.Abs(Time.Elapsed) / 40, 0, 1));
         }
 
+        private int wholeSpins;
+
+        private void updateBonusScore()
+        {
+            if (ticks.Count == 0)
+                return;
+
+            int spins = (int)(Disc.CumulativeRotation / 360);
+
+            while (wholeSpins != spins)
+            {
+                if (wholeSpins < spins)
+                {
+                    var tick = ticks.FirstOrDefault(t => !t.IsHit);
+
+                    if (tick != null)
+                    {
+                        tick.TriggerResult(HitResult.Great);
+                        if (tick is DrawableSpinnerBonusTick)
+                            bonusDisplay.SetBonusCount(spins - Spinner.SpinsRequired);
+                    }
+
+                    wholeSpins++;
+                }
+                else
+                {
+                    wholeSpins--;
+                }
+            }
+        }
+
         protected override void UpdateInitialTransforms()
         {
             base.UpdateInitialTransforms();
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
index 5fb7653f5a..6c9570c381 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
@@ -17,11 +17,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         /// <summary>
         /// Apply a judgement result.
         /// </summary>
-        /// <param name="hit">Whether to apply a <see cref="HitResult.Great"/> result, <see cref="HitResult.Miss"/> otherwise.</param>
-        internal void TriggerResult(bool hit)
+        /// <param name="result">Whether to apply a <see cref="HitResult.Great"/> result, <see cref="HitResult.Miss"/> otherwise.</param>
+        internal void TriggerResult(HitResult result)
         {
-            HitObject.StartTime = Time.Current;
-            ApplyResult(r => r.Type = hit ? HitResult.Great : HitResult.Miss);
+            ApplyResult(r => r.Type = result);
         }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs
deleted file mode 100644
index 9a65247453..0000000000
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusComponent.cs
+++ /dev/null
@@ -1,87 +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;
-using System.Linq;
-using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Graphics;
-using osu.Game.Graphics.Sprites;
-using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Objects.Drawables;
-
-namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
-{
-    /// <summary>
-    /// A component that tracks spinner spins and add bonus score for it.
-    /// </summary>
-    public class SpinnerBonusComponent : CompositeDrawable
-    {
-        private readonly DrawableSpinner drawableSpinner;
-        private readonly Container<DrawableSpinnerTick> ticks;
-        private readonly OsuSpriteText bonusCounter;
-
-        public SpinnerBonusComponent(DrawableSpinner drawableSpinner, Container<DrawableSpinnerTick> ticks)
-        {
-            this.drawableSpinner = drawableSpinner;
-            this.ticks = ticks;
-
-            drawableSpinner.OnNewResult += onNewResult;
-
-            AutoSizeAxes = Axes.Both;
-            InternalChild = bonusCounter = new OsuSpriteText
-            {
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                Font = OsuFont.Numeric.With(size: 24),
-                Alpha = 0,
-            };
-        }
-
-        private int currentSpins;
-
-        public void SetRotation(double rotation)
-        {
-            if (ticks.Count == 0)
-                return;
-
-            int spinsRequired = ((Spinner)drawableSpinner.HitObject).SpinsRequired;
-
-            int newSpins = Math.Clamp((int)(rotation / 360), 0, ticks.Count - 1);
-            int direction = Math.Sign(newSpins - currentSpins);
-
-            while (currentSpins != newSpins)
-            {
-                var tick = ticks[currentSpins];
-
-                if (direction >= 0)
-                    tick.TriggerResult(true);
-
-                if (tick is DrawableSpinnerBonusTick)
-                {
-                    bonusCounter.Text = $"{1000 * (currentSpins - spinsRequired)}";
-                    bonusCounter.FadeOutFromOne(1500);
-                    bonusCounter.ScaleTo(1.5f).Then().ScaleTo(1f, 1000, Easing.OutQuint);
-                }
-
-                currentSpins += direction;
-            }
-        }
-
-        private void onNewResult(DrawableHitObject hitObject, JudgementResult result)
-        {
-            if (!result.HasResult || hitObject != drawableSpinner)
-                return;
-
-            // Trigger a miss result for remaining ticks to avoid infinite gameplay.
-            foreach (var tick in ticks.Where(t => !t.IsHit))
-                tick.TriggerResult(false);
-        }
-
-        protected override void Dispose(bool isDisposing)
-        {
-            base.Dispose(isDisposing);
-            drawableSpinner.OnNewResult -= onNewResult;
-        }
-    }
-}
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusDisplay.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusDisplay.cs
new file mode 100644
index 0000000000..76d7f1843e
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusDisplay.cs
@@ -0,0 +1,44 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    /// <summary>
+    /// A component that tracks spinner spins and add bonus score for it.
+    /// </summary>
+    public class SpinnerBonusDisplay : CompositeDrawable
+    {
+        private readonly OsuSpriteText bonusCounter;
+
+        public SpinnerBonusDisplay()
+        {
+            AutoSizeAxes = Axes.Both;
+
+            InternalChild = bonusCounter = new OsuSpriteText
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Font = OsuFont.Numeric.With(size: 24),
+                Alpha = 0,
+            };
+        }
+
+        private int displayedCount;
+
+        public void SetBonusCount(int count)
+        {
+            if (displayedCount == count)
+                return;
+
+            displayedCount = count;
+            bonusCounter.Text = $"{1000 * count}";
+            bonusCounter.FadeOutFromOne(1500);
+            bonusCounter.ScaleTo(1.5f).Then().ScaleTo(1f, 1000, Easing.OutQuint);
+        }
+    }
+}

From 7f2ae694cc96e41175932d16353fa3e1c0a3e9ba Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Tue, 21 Jul 2020 19:21:30 +0900
Subject: [PATCH 20/27] Simplify rewind handling

---
 .../Objects/Drawables/DrawableSpinner.cs      | 29 ++++++++++---------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index df6eb206da..a8ecb60038 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -253,25 +253,26 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             int spins = (int)(Disc.CumulativeRotation / 360);
 
+            if (spins < wholeSpins)
+            {
+                // rewinding, silently handle
+                wholeSpins = spins;
+                return;
+            }
+
             while (wholeSpins != spins)
             {
-                if (wholeSpins < spins)
-                {
-                    var tick = ticks.FirstOrDefault(t => !t.IsHit);
+                var tick = ticks.FirstOrDefault(t => !t.IsHit);
 
-                    if (tick != null)
-                    {
-                        tick.TriggerResult(HitResult.Great);
-                        if (tick is DrawableSpinnerBonusTick)
-                            bonusDisplay.SetBonusCount(spins - Spinner.SpinsRequired);
-                    }
-
-                    wholeSpins++;
-                }
-                else
+                // tick may be null if we've hit the spin limit.
+                if (tick != null)
                 {
-                    wholeSpins--;
+                    tick.TriggerResult(HitResult.Great);
+                    if (tick is DrawableSpinnerBonusTick)
+                        bonusDisplay.SetBonusCount(spins - Spinner.SpinsRequired);
                 }
+
+                wholeSpins++;
             }
         }
 

From a4680d7a8945ded3804b0a0b84500a0a47241e44 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Tue, 21 Jul 2020 19:22:42 +0900
Subject: [PATCH 21/27] Reduce test range as to not hit spin cat

---
 osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs
index 0f1cbcd44c..6e277ff37e 100644
--- a/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs
+++ b/osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs
@@ -164,13 +164,13 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             double estimatedSpm = 0;
 
-            addSeekStep(2500);
+            addSeekStep(1000);
             AddStep("retrieve spm", () => estimatedSpm = drawableSpinner.SpmCounter.SpinsPerMinute);
 
-            addSeekStep(5000);
+            addSeekStep(2000);
             AddAssert("spm still valid", () => Precision.AlmostEquals(drawableSpinner.SpmCounter.SpinsPerMinute, estimatedSpm, 1.0));
 
-            addSeekStep(2500);
+            addSeekStep(1000);
             AddAssert("spm still valid", () => Precision.AlmostEquals(drawableSpinner.SpmCounter.SpinsPerMinute, estimatedSpm, 1.0));
         }
 

From 1560e1786a09475d4537bfc02b881d8bb2f422f3 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Tue, 21 Jul 2020 19:48:44 +0900
Subject: [PATCH 22/27] Revert back to bool for application

---
 osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs | 4 ++--
 .../Objects/Drawables/DrawableSpinnerTick.cs               | 7 ++-----
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
index a8ecb60038..ecf78efdd9 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs
@@ -201,7 +201,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             // Trigger a miss result for remaining ticks to avoid infinite gameplay.
             foreach (var tick in ticks.Where(t => !t.IsHit))
-                tick.TriggerResult(HitResult.Miss);
+                tick.TriggerResult(false);
 
             ApplyResult(r =>
             {
@@ -267,7 +267,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 // tick may be null if we've hit the spin limit.
                 if (tick != null)
                 {
-                    tick.TriggerResult(HitResult.Great);
+                    tick.TriggerResult(true);
                     if (tick is DrawableSpinnerBonusTick)
                         bonusDisplay.SetBonusCount(spins - Spinner.SpinsRequired);
                 }
diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
index 6c9570c381..c390b673be 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinnerTick.cs
@@ -17,10 +17,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         /// <summary>
         /// Apply a judgement result.
         /// </summary>
-        /// <param name="result">Whether to apply a <see cref="HitResult.Great"/> result, <see cref="HitResult.Miss"/> otherwise.</param>
-        internal void TriggerResult(HitResult result)
-        {
-            ApplyResult(r => r.Type = result);
-        }
+        /// <param name="hit">Whether this tick was reached.</param>
+        internal void TriggerResult(bool hit) => ApplyResult(r => r.Type = hit ? r.Judgement.MaxResult : HitResult.Miss);
     }
 }

From bc079fccf52d5d338609ca87249208a899343958 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Tue, 21 Jul 2020 19:52:16 +0900
Subject: [PATCH 23/27] Add health drain for spinner ticks

---
 osu.Game.Rulesets.Osu/Objects/SpinnerBonusTick.cs | 2 ++
 osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs      | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/SpinnerBonusTick.cs b/osu.Game.Rulesets.Osu/Objects/SpinnerBonusTick.cs
index 84eb58c70b..6ca2d4d72d 100644
--- a/osu.Game.Rulesets.Osu/Objects/SpinnerBonusTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/SpinnerBonusTick.cs
@@ -19,6 +19,8 @@ namespace osu.Game.Rulesets.Osu.Objects
         public class OsuSpinnerBonusTickJudgement : OsuSpinnerTickJudgement
         {
             protected override int NumericResultFor(HitResult result) => 1100;
+
+            protected override double HealthIncreaseFor(HitResult result) => base.HealthIncreaseFor(result) * 2;
         }
     }
 }
diff --git a/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs b/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
index 89ad45b267..c81348fbbf 100644
--- a/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
+++ b/osu.Game.Rulesets.Osu/Objects/SpinnerTick.cs
@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Osu.Objects
 
             protected override int NumericResultFor(HitResult result) => 100;
 
-            protected override double HealthIncreaseFor(HitResult result) => 0;
+            protected override double HealthIncreaseFor(HitResult result) => result == MaxResult ? 0.6 * base.HealthIncreaseFor(result) : 0;
         }
     }
 }

From eb84f2503657fe5c8332e18c20ac9b0281d45d87 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Fri, 24 Jul 2020 19:34:13 +0900
Subject: [PATCH 24/27] Adjust maximum spins to roughly match stable

---
 osu.Game.Rulesets.Osu/Objects/Spinner.cs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Spinner.cs b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
index 1c30058d5d..9699ab9502 100644
--- a/osu.Game.Rulesets.Osu/Objects/Spinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
@@ -26,7 +26,10 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// </summary>
         public int SpinsRequired { get; protected set; } = 1;
 
-        public int MaximumBonusSpins => SpinsRequired;
+        /// <summary>
+        /// Number of spins available to give bonus, beyond <see cref="SpinsRequired"/>.
+        /// </summary>
+        public int MaximumBonusSpins => (int)(SpinsRequired * 1.8f); // roughly matches stable
 
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {

From 82e4050fddb27908c282a5f307f62b22ef62940c Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Fri, 24 Jul 2020 19:41:34 +0900
Subject: [PATCH 25/27] Fix xmldoc

---
 .../Objects/Drawables/Pieces/SpinnerBonusDisplay.cs             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusDisplay.cs b/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusDisplay.cs
index 76d7f1843e..a8f5580735 100644
--- a/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusDisplay.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBonusDisplay.cs
@@ -9,7 +9,7 @@ using osu.Game.Graphics.Sprites;
 namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 {
     /// <summary>
-    /// A component that tracks spinner spins and add bonus score for it.
+    /// Shows incremental bonus score achieved for a spinner.
     /// </summary>
     public class SpinnerBonusDisplay : CompositeDrawable
     {

From dd45f0bd40d7aad6def77ce95ed2d2013cd03082 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Fri, 24 Jul 2020 21:03:55 +0900
Subject: [PATCH 26/27] Adjust max spins to "match" stable

---
 osu.Game.Rulesets.Osu/Objects/Spinner.cs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Spinner.cs b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
index 9699ab9502..2c03e6eeac 100644
--- a/osu.Game.Rulesets.Osu/Objects/Spinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
@@ -29,16 +29,21 @@ namespace osu.Game.Rulesets.Osu.Objects
         /// <summary>
         /// Number of spins available to give bonus, beyond <see cref="SpinsRequired"/>.
         /// </summary>
-        public int MaximumBonusSpins => (int)(SpinsRequired * 1.8f); // roughly matches stable
+        public int MaximumBonusSpins { get; protected set; } = 1;
 
         protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
-            SpinsRequired = (int)(Duration / 1000 * BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5));
+            double secondsDuration = Duration / 1000;
 
             // spinning doesn't match 1:1 with stable, so let's fudge them easier for the time being.
-            SpinsRequired = (int)Math.Max(1, SpinsRequired * 0.6);
+            double minimumRotationsPerSecond = 0.6 * BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5);
+
+            const double maximum_rotations_per_second = 8; // close to 477rpm.
+
+            SpinsRequired = (int)Math.Max(1, (secondsDuration * minimumRotationsPerSecond));
+            MaximumBonusSpins = (int)(maximum_rotations_per_second / minimumRotationsPerSecond * secondsDuration);
         }
 
         protected override void CreateNestedHitObjects()

From a6a7961af9c2788202055efff6a9e42cfd3a7344 Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Fri, 24 Jul 2020 22:09:25 +0900
Subject: [PATCH 27/27] Change div to subtraction to fix calculation

---
 osu.Game.Rulesets.Osu/Objects/Spinner.cs | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/osu.Game.Rulesets.Osu/Objects/Spinner.cs b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
index 2c03e6eeac..619b49926e 100644
--- a/osu.Game.Rulesets.Osu/Objects/Spinner.cs
+++ b/osu.Game.Rulesets.Osu/Objects/Spinner.cs
@@ -35,15 +35,18 @@ namespace osu.Game.Rulesets.Osu.Objects
         {
             base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
 
+            // spinning doesn't match 1:1 with stable, so let's fudge them easier for the time being.
+            const double stable_matching_fudge = 0.6;
+
+            // close to 477rpm
+            const double maximum_rotations_per_second = 8;
+
             double secondsDuration = Duration / 1000;
 
-            // spinning doesn't match 1:1 with stable, so let's fudge them easier for the time being.
-            double minimumRotationsPerSecond = 0.6 * BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5);
-
-            const double maximum_rotations_per_second = 8; // close to 477rpm.
+            double minimumRotationsPerSecond = stable_matching_fudge * BeatmapDifficulty.DifficultyRange(difficulty.OverallDifficulty, 3, 5, 7.5);
 
             SpinsRequired = (int)Math.Max(1, (secondsDuration * minimumRotationsPerSecond));
-            MaximumBonusSpins = (int)(maximum_rotations_per_second / minimumRotationsPerSecond * secondsDuration);
+            MaximumBonusSpins = (int)((maximum_rotations_per_second - minimumRotationsPerSecond) * secondsDuration);
         }
 
         protected override void CreateNestedHitObjects()