From 812a4b412a2c1b13a1e1215a00f863ef6fd83e45 Mon Sep 17 00:00:00 2001
From: ekrctb <ekrctb@gmail.com>
Date: Thu, 19 Jan 2023 19:43:23 +0900
Subject: [PATCH 01/11] Move judgement result revert logic to Playfield
 Previously, some judgement results were not reverted when the source DHO is
 not alive (e.g. frames skipped in editor). Now, all results are reverted in
 the exact reverse order.

---
 .../TestSceneCatcher.cs                       |  6 +--
 .../UI/CatchComboDisplay.cs                   |  4 +-
 osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs  |  4 +-
 osu.Game.Rulesets.Catch/UI/Catcher.cs         |  6 +--
 osu.Game.Rulesets.Catch/UI/CatcherArea.cs     |  6 +--
 .../Judgements/JudgementResultEntry.cs        | 26 +++++++++++++
 .../Objects/Drawables/DrawableHitObject.cs    | 35 ++++++-----------
 .../Objects/HitObjectLifetimeEntry.cs         |  5 +++
 osu.Game/Rulesets/UI/DrawableRuleset.cs       |  2 +-
 osu.Game/Rulesets/UI/HitObjectContainer.cs    |  8 ----
 osu.Game/Rulesets/UI/Playfield.cs             | 38 ++++++++++++++++---
 11 files changed, 90 insertions(+), 50 deletions(-)
 create mode 100644 osu.Game/Rulesets/Judgements/JudgementResultEntry.cs

diff --git a/osu.Game.Rulesets.Catch.Tests/TestSceneCatcher.cs b/osu.Game.Rulesets.Catch.Tests/TestSceneCatcher.cs
index e8231b07ad..11e3a5be57 100644
--- a/osu.Game.Rulesets.Catch.Tests/TestSceneCatcher.cs
+++ b/osu.Game.Rulesets.Catch.Tests/TestSceneCatcher.cs
@@ -74,12 +74,12 @@ namespace osu.Game.Rulesets.Catch.Tests
             });
             AddStep("revert second result", () =>
             {
-                catcher.OnRevertResult(drawableObject2, result2);
+                catcher.OnRevertResult(result2);
             });
             checkHyperDash(true);
             AddStep("revert first result", () =>
             {
-                catcher.OnRevertResult(drawableObject1, result1);
+                catcher.OnRevertResult(result1);
             });
             checkHyperDash(false);
         }
@@ -96,7 +96,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             checkState(CatcherAnimationState.Kiai);
             AddStep("revert result", () =>
             {
-                catcher.OnRevertResult(drawableObject, result);
+                catcher.OnRevertResult(result);
             });
             checkState(CatcherAnimationState.Idle);
         }
diff --git a/osu.Game.Rulesets.Catch/UI/CatchComboDisplay.cs b/osu.Game.Rulesets.Catch/UI/CatchComboDisplay.cs
index dbbe905879..3d0062d32f 100644
--- a/osu.Game.Rulesets.Catch/UI/CatchComboDisplay.cs
+++ b/osu.Game.Rulesets.Catch/UI/CatchComboDisplay.cs
@@ -63,12 +63,12 @@ namespace osu.Game.Rulesets.Catch.UI
             updateCombo(result.ComboAtJudgement + 1, judgedObject.AccentColour.Value);
         }
 
-        public void OnRevertResult(DrawableCatchHitObject judgedObject, JudgementResult result)
+        public void OnRevertResult(JudgementResult result)
         {
             if (!result.Type.AffectsCombo() || !result.HasResult)
                 return;
 
-            updateCombo(result.ComboAtJudgement, judgedObject.AccentColour.Value);
+            updateCombo(result.ComboAtJudgement, null);
         }
 
         private void updateCombo(int newCombo, Color4? hitObjectColour)
diff --git a/osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs b/osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs
index c33d021876..cf7337fd0d 100644
--- a/osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs
+++ b/osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs
@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Catch.UI
         private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
             => CatcherArea.OnNewResult((DrawableCatchHitObject)judgedObject, result);
 
-        private void onRevertResult(DrawableHitObject judgedObject, JudgementResult result)
-            => CatcherArea.OnRevertResult((DrawableCatchHitObject)judgedObject, result);
+        private void onRevertResult(JudgementResult result)
+            => CatcherArea.OnRevertResult(result);
     }
 }
diff --git a/osu.Game.Rulesets.Catch/UI/Catcher.cs b/osu.Game.Rulesets.Catch/UI/Catcher.cs
index 411330f6fc..1c52c092ec 100644
--- a/osu.Game.Rulesets.Catch/UI/Catcher.cs
+++ b/osu.Game.Rulesets.Catch/UI/Catcher.cs
@@ -254,7 +254,7 @@ namespace osu.Game.Rulesets.Catch.UI
             }
         }
 
-        public void OnRevertResult(DrawableCatchHitObject drawableObject, JudgementResult result)
+        public void OnRevertResult(JudgementResult result)
         {
             var catchResult = (CatchJudgementResult)result;
 
@@ -268,8 +268,8 @@ namespace osu.Game.Rulesets.Catch.UI
                     SetHyperDashState();
             }
 
-            caughtObjectContainer.RemoveAll(d => d.HitObject == drawableObject.HitObject, false);
-            droppedObjectTarget.RemoveAll(d => d.HitObject == drawableObject.HitObject, false);
+            caughtObjectContainer.RemoveAll(d => d.HitObject == result.HitObject, false);
+            droppedObjectTarget.RemoveAll(d => d.HitObject == result.HitObject, false);
         }
 
         /// <summary>
diff --git a/osu.Game.Rulesets.Catch/UI/CatcherArea.cs b/osu.Game.Rulesets.Catch/UI/CatcherArea.cs
index 4f7535d13a..1b99270b65 100644
--- a/osu.Game.Rulesets.Catch/UI/CatcherArea.cs
+++ b/osu.Game.Rulesets.Catch/UI/CatcherArea.cs
@@ -73,10 +73,10 @@ namespace osu.Game.Rulesets.Catch.UI
             comboDisplay.OnNewResult(hitObject, result);
         }
 
-        public void OnRevertResult(DrawableCatchHitObject hitObject, JudgementResult result)
+        public void OnRevertResult(JudgementResult result)
         {
-            comboDisplay.OnRevertResult(hitObject, result);
-            Catcher.OnRevertResult(hitObject, result);
+            comboDisplay.OnRevertResult(result);
+            Catcher.OnRevertResult(result);
         }
 
         protected override void Update()
diff --git a/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs b/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs
new file mode 100644
index 0000000000..c3f44804c3
--- /dev/null
+++ b/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs
@@ -0,0 +1,26 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Judgements
+{
+    internal class JudgementResultEntry : IComparable<JudgementResultEntry>
+    {
+        public readonly double Time;
+
+        public readonly HitObjectLifetimeEntry HitObjectEntry;
+
+        public readonly JudgementResult Result;
+
+        public JudgementResultEntry(double time, HitObjectLifetimeEntry hitObjectEntry, JudgementResult result)
+        {
+            Time = time;
+            HitObjectEntry = hitObjectEntry;
+            Result = result;
+        }
+
+        public int CompareTo(JudgementResultEntry? other) => Time.CompareTo(other?.Time);
+    }
+}
\ No newline at end of file
diff --git a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
index be5a7f71e7..02fc5637d8 100644
--- a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
+++ b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
@@ -82,6 +82,9 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// <summary>
         /// Invoked by this or a nested <see cref="DrawableHitObject"/> prior to a <see cref="JudgementResult"/> being reverted.
         /// </summary>
+        /// <remarks>
+        /// This is only invoked if this <see cref="DrawableHitObject"/> is alive when the result is reverted.
+        /// </remarks>
         public event Action<DrawableHitObject, JudgementResult> OnRevertResult;
 
         /// <summary>
@@ -222,6 +225,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
             ensureEntryHasResult();
 
+            entry.RevertResult += onRevertResult;
+
             foreach (var h in HitObject.NestedHitObjects)
             {
                 var pooledDrawableNested = pooledObjectProvider?.GetPooledDrawableRepresentation(h, this);
@@ -234,7 +239,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
                     OnNestedDrawableCreated?.Invoke(drawableNested);
 
                 drawableNested.OnNewResult += onNewResult;
-                drawableNested.OnRevertResult += onRevertResult;
                 drawableNested.ApplyCustomUpdateState += onApplyCustomUpdateState;
 
                 // This is only necessary for non-pooled DHOs. For pooled DHOs, this is handled inside GetPooledDrawableRepresentation().
@@ -309,7 +313,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
             foreach (var obj in nestedHitObjects)
             {
                 obj.OnNewResult -= onNewResult;
-                obj.OnRevertResult -= onRevertResult;
                 obj.ApplyCustomUpdateState -= onApplyCustomUpdateState;
             }
 
@@ -318,6 +321,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
             HitObject.DefaultsApplied -= onDefaultsApplied;
 
+            entry.RevertResult -= onRevertResult;
+
             OnFree();
 
             ParentHitObject = null;
@@ -366,7 +371,11 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         private void onNewResult(DrawableHitObject drawableHitObject, JudgementResult result) => OnNewResult?.Invoke(drawableHitObject, result);
 
-        private void onRevertResult(DrawableHitObject drawableHitObject, JudgementResult result) => OnRevertResult?.Invoke(drawableHitObject, result);
+        private void onRevertResult()
+        {
+            updateState(ArmedState.Idle);
+            OnRevertResult?.Invoke(this, Result);
+        }
 
         private void onApplyCustomUpdateState(DrawableHitObject drawableHitObject, ArmedState state) => ApplyCustomUpdateState?.Invoke(drawableHitObject, state);
 
@@ -578,26 +587,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         #endregion
 
-        protected override void Update()
-        {
-            base.Update();
-
-            if (Result != null && Result.HasResult)
-            {
-                double endTime = HitObject.GetEndTime();
-
-                if (Result.TimeOffset + endTime > Time.Current)
-                {
-                    OnRevertResult?.Invoke(this, Result);
-
-                    Result.TimeOffset = 0;
-                    Result.Type = HitResult.None;
-
-                    updateState(ArmedState.Idle);
-                }
-            }
-        }
-
         public override bool UpdateSubTreeMasking(Drawable source, RectangleF maskingBounds) => false;
 
         protected override void UpdateAfterChildren()
diff --git a/osu.Game/Rulesets/Objects/HitObjectLifetimeEntry.cs b/osu.Game/Rulesets/Objects/HitObjectLifetimeEntry.cs
index fedf419973..b517f6b9e6 100644
--- a/osu.Game/Rulesets/Objects/HitObjectLifetimeEntry.cs
+++ b/osu.Game/Rulesets/Objects/HitObjectLifetimeEntry.cs
@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics.Performance;
 using osu.Game.Rulesets.Judgements;
@@ -26,6 +27,8 @@ namespace osu.Game.Rulesets.Objects
 
         private readonly IBindable<double> startTimeBindable = new BindableDouble();
 
+        internal event Action? RevertResult;
+
         /// <summary>
         /// Creates a new <see cref="HitObjectLifetimeEntry"/>.
         /// </summary>
@@ -95,5 +98,7 @@ namespace osu.Game.Rulesets.Objects
         /// Set <see cref="LifetimeEntry.LifetimeStart"/> using <see cref="InitialLifetimeOffset"/>.
         /// </summary>
         internal void SetInitialLifetime() => LifetimeStart = HitObject.StartTime - InitialLifetimeOffset;
+
+        internal void OnRevertResult() => RevertResult?.Invoke();
     }
 }
diff --git a/osu.Game/Rulesets/UI/DrawableRuleset.cs b/osu.Game/Rulesets/UI/DrawableRuleset.cs
index 71b452c309..8edc5517cb 100644
--- a/osu.Game/Rulesets/UI/DrawableRuleset.cs
+++ b/osu.Game/Rulesets/UI/DrawableRuleset.cs
@@ -134,7 +134,7 @@ namespace osu.Game.Rulesets.UI
             playfield = new Lazy<Playfield>(() => CreatePlayfield().With(p =>
             {
                 p.NewResult += (_, r) => NewResult?.Invoke(r);
-                p.RevertResult += (_, r) => RevertResult?.Invoke(r);
+                p.RevertResult += r => RevertResult?.Invoke(r);
             }));
         }
 
diff --git a/osu.Game/Rulesets/UI/HitObjectContainer.cs b/osu.Game/Rulesets/UI/HitObjectContainer.cs
index 7cbf49aa31..099be486b3 100644
--- a/osu.Game/Rulesets/UI/HitObjectContainer.cs
+++ b/osu.Game/Rulesets/UI/HitObjectContainer.cs
@@ -28,11 +28,6 @@ namespace osu.Game.Rulesets.UI
         /// </summary>
         public event Action<DrawableHitObject, JudgementResult> NewResult;
 
-        /// <summary>
-        /// Invoked when a <see cref="DrawableHitObject"/> judgement is reverted.
-        /// </summary>
-        public event Action<DrawableHitObject, JudgementResult> RevertResult;
-
         /// <summary>
         /// Invoked when a <see cref="HitObject"/> becomes used by a <see cref="DrawableHitObject"/>.
         /// </summary>
@@ -111,7 +106,6 @@ namespace osu.Game.Rulesets.UI
         private void addDrawable(DrawableHitObject drawable)
         {
             drawable.OnNewResult += onNewResult;
-            drawable.OnRevertResult += onRevertResult;
 
             bindStartTime(drawable);
             AddInternal(drawable);
@@ -120,7 +114,6 @@ namespace osu.Game.Rulesets.UI
         private void removeDrawable(DrawableHitObject drawable)
         {
             drawable.OnNewResult -= onNewResult;
-            drawable.OnRevertResult -= onRevertResult;
 
             unbindStartTime(drawable);
 
@@ -154,7 +147,6 @@ namespace osu.Game.Rulesets.UI
         #endregion
 
         private void onNewResult(DrawableHitObject d, JudgementResult r) => NewResult?.Invoke(d, r);
-        private void onRevertResult(DrawableHitObject d, JudgementResult r) => RevertResult?.Invoke(d, r);
 
         #region Comparator + StartTime tracking
 
diff --git a/osu.Game/Rulesets/UI/Playfield.cs b/osu.Game/Rulesets/UI/Playfield.cs
index a7881678f1..9535ebb9ed 100644
--- a/osu.Game/Rulesets/UI/Playfield.cs
+++ b/osu.Game/Rulesets/UI/Playfield.cs
@@ -22,6 +22,8 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Skinning;
 using osuTK;
 using osu.Game.Rulesets.Objects.Pooling;
+using osu.Game.Rulesets.Scoring;
+using osu.Framework.Extensions.ObjectExtensions;
 
 namespace osu.Game.Rulesets.UI
 {
@@ -35,9 +37,9 @@ namespace osu.Game.Rulesets.UI
         public event Action<DrawableHitObject, JudgementResult> NewResult;
 
         /// <summary>
-        /// Invoked when a <see cref="DrawableHitObject"/> judgement is reverted.
+        /// Invoked when a judgement result is reverted.
         /// </summary>
-        public event Action<DrawableHitObject, JudgementResult> RevertResult;
+        public event Action<JudgementResult> RevertResult;
 
         /// <summary>
         /// The <see cref="DrawableHitObject"/> contained in this Playfield.
@@ -98,6 +100,8 @@ namespace osu.Game.Rulesets.UI
 
         private readonly HitObjectEntryManager entryManager = new HitObjectEntryManager();
 
+        private readonly Stack<JudgementResultEntry> judgementResults;
+
         /// <summary>
         /// Creates a new <see cref="Playfield"/>.
         /// </summary>
@@ -107,14 +111,15 @@ namespace osu.Game.Rulesets.UI
 
             hitObjectContainerLazy = new Lazy<HitObjectContainer>(() => CreateHitObjectContainer().With(h =>
             {
-                h.NewResult += (d, r) => NewResult?.Invoke(d, r);
-                h.RevertResult += (d, r) => RevertResult?.Invoke(d, r);
+                h.NewResult += onNewResult;
                 h.HitObjectUsageBegan += o => HitObjectUsageBegan?.Invoke(o);
                 h.HitObjectUsageFinished += o => HitObjectUsageFinished?.Invoke(o);
             }));
 
             entryManager.OnEntryAdded += onEntryAdded;
             entryManager.OnEntryRemoved += onEntryRemoved;
+
+            judgementResults = new Stack<JudgementResultEntry>();
         }
 
         [BackgroundDependencyLoader]
@@ -224,7 +229,7 @@ namespace osu.Game.Rulesets.UI
             otherPlayfield.DisplayJudgements.BindTo(DisplayJudgements);
 
             otherPlayfield.NewResult += (d, r) => NewResult?.Invoke(d, r);
-            otherPlayfield.RevertResult += (d, r) => RevertResult?.Invoke(d, r);
+            otherPlayfield.RevertResult += r => RevertResult?.Invoke(r);
             otherPlayfield.HitObjectUsageBegan += h => HitObjectUsageBegan?.Invoke(h);
             otherPlayfield.HitObjectUsageFinished += h => HitObjectUsageFinished?.Invoke(h);
 
@@ -252,6 +257,10 @@ namespace osu.Game.Rulesets.UI
                         updatable.Update(this);
                 }
             }
+
+            // When rewinding, revert future judgements in the reverse order.
+            while (judgementResults.Count > 0 && Time.Current < judgementResults.Peek().Time)
+                revertResult(judgementResults.Pop());
         }
 
         /// <summary>
@@ -443,6 +452,25 @@ namespace osu.Game.Rulesets.UI
 
         #endregion
 
+        private void onNewResult(DrawableHitObject drawable, JudgementResult result)
+        {
+            // Not using result.TimeAbsolute because that might change and also there is a potential precision issue.
+            judgementResults.Push(new JudgementResultEntry(Time.Current, drawable.Entry.AsNonNull(), result));
+
+            NewResult?.Invoke(drawable, result);
+        }
+
+        private void revertResult(JudgementResultEntry entry)
+        {
+            var result = entry.Result;
+            RevertResult?.Invoke(result);
+
+            result.TimeOffset = 0;
+            result.Type = HitResult.None;
+
+            entry.HitObjectEntry.OnRevertResult();
+        }
+
         #region Editor logic
 
         /// <summary>

From 32acaa44be3009b3120e05753308e157c8f0219a Mon Sep 17 00:00:00 2001
From: ekrctb <ekrctb@gmail.com>
Date: Thu, 19 Jan 2023 19:52:37 +0900
Subject: [PATCH 02/11] Remove now-redundant code

---
 .../TestSceneCatcher.cs                       | 23 +++++++------------
 1 file changed, 8 insertions(+), 15 deletions(-)

diff --git a/osu.Game.Rulesets.Catch.Tests/TestSceneCatcher.cs b/osu.Game.Rulesets.Catch.Tests/TestSceneCatcher.cs
index 11e3a5be57..f60ae29f77 100644
--- a/osu.Game.Rulesets.Catch.Tests/TestSceneCatcher.cs
+++ b/osu.Game.Rulesets.Catch.Tests/TestSceneCatcher.cs
@@ -60,17 +60,15 @@ namespace osu.Game.Rulesets.Catch.Tests
         [Test]
         public void TestCatcherHyperStateReverted()
         {
-            DrawableCatchHitObject drawableObject1 = null;
-            DrawableCatchHitObject drawableObject2 = null;
             JudgementResult result1 = null;
             JudgementResult result2 = null;
             AddStep("catch hyper fruit", () =>
             {
-                attemptCatch(new Fruit { HyperDashTarget = new Fruit { X = 100 } }, out drawableObject1, out result1);
+                result1 = attemptCatch(new Fruit { HyperDashTarget = new Fruit { X = 100 } });
             });
             AddStep("catch normal fruit", () =>
             {
-                attemptCatch(new Fruit(), out drawableObject2, out result2);
+                result2 = attemptCatch(new Fruit());
             });
             AddStep("revert second result", () =>
             {
@@ -87,11 +85,10 @@ namespace osu.Game.Rulesets.Catch.Tests
         [Test]
         public void TestCatcherAnimationStateReverted()
         {
-            DrawableCatchHitObject drawableObject = null;
             JudgementResult result = null;
             AddStep("catch kiai fruit", () =>
             {
-                attemptCatch(new TestKiaiFruit(), out drawableObject, out result);
+                result = attemptCatch(new TestKiaiFruit());
             });
             checkState(CatcherAnimationState.Kiai);
             AddStep("revert result", () =>
@@ -268,23 +265,19 @@ namespace osu.Game.Rulesets.Catch.Tests
 
         private void checkHyperDash(bool state) => AddAssert($"catcher is {(state ? "" : "not ")}hyper dashing", () => catcher.HyperDashing == state);
 
-        private void attemptCatch(CatchHitObject hitObject)
-        {
-            attemptCatch(() => hitObject, 1);
-        }
-
         private void attemptCatch(Func<CatchHitObject> hitObject, int count)
         {
             for (int i = 0; i < count; i++)
-                attemptCatch(hitObject(), out _, out _);
+                attemptCatch(hitObject());
         }
 
-        private void attemptCatch(CatchHitObject hitObject, out DrawableCatchHitObject drawableObject, out JudgementResult result)
+        private JudgementResult attemptCatch(CatchHitObject hitObject)
         {
             hitObject.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
-            drawableObject = createDrawableObject(hitObject);
-            result = createResult(hitObject);
+            var drawableObject = createDrawableObject(hitObject);
+            var result = createResult(hitObject);
             applyResult(drawableObject, result);
+            return result;
         }
 
         private void applyResult(DrawableCatchHitObject drawableObject, JudgementResult result)

From 8405a3e1722f0b3b3d11d2ff33a08fb1dfdafb56 Mon Sep 17 00:00:00 2001
From: ekrctb <ekrctb@gmail.com>
Date: Mon, 23 Jan 2023 18:51:55 +0900
Subject: [PATCH 03/11] Add test for RevertResult

---
 .../Gameplay/TestScenePoolingRuleset.cs       | 57 +++++++++++++++----
 1 file changed, 45 insertions(+), 12 deletions(-)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
index 55ee6c9fc9..22ab74cc30 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
@@ -19,7 +19,6 @@ using osu.Framework.Utils;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets;
 using osu.Game.Rulesets.Difficulty;
-using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -37,6 +36,8 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private TestDrawablePoolingRuleset drawableRuleset;
 
+        private TestPlayfield playfield => (TestPlayfield)drawableRuleset.Playfield;
+
         [Test]
         public void TestReusedWithHitObjectsSpacedFarApart()
         {
@@ -133,29 +134,49 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddUntilStep("no DHOs shown", () => !this.ChildrenOfType<DrawableTestHitObject>().Any());
         }
 
+        [Test]
+        public void TestRevertResult()
+        {
+            ManualClock clock = null;
+            Beatmap beatmap;
+
+            createTest(beatmap = new Beatmap
+            {
+                HitObjects =
+                {
+                    new TestHitObject { StartTime = 0 },
+                    new TestHitObject { StartTime = 500 },
+                    new TestHitObject { StartTime = 1000 },
+                }
+            }, 10, () => new FramedClock(clock = new ManualClock()));
+
+            AddStep("fast forward to end", () => clock.CurrentTime = beatmap.HitObjects[^1].GetEndTime() + 100);
+            AddUntilStep("all judged", () => playfield.JudgedObjects.Count == 3);
+
+            AddStep("rewind to middle", () => clock.CurrentTime = beatmap.HitObjects[1].StartTime - 100);
+            AddUntilStep("some results reverted", () => playfield.JudgedObjects.Count == 1);
+
+            AddStep("fast forward to end", () => clock.CurrentTime = beatmap.HitObjects[^1].GetEndTime() + 100);
+            AddUntilStep("all judged", () => playfield.JudgedObjects.Count == 3);
+
+            AddStep("disable frame stability", () => drawableRuleset.FrameStablePlayback = false);
+            AddStep("instant seek to start", () => clock.CurrentTime = beatmap.HitObjects[0].StartTime - 100);
+            AddAssert("all results reverted", () => playfield.JudgedObjects.Count == 0);
+        }
+
         [Test]
         public void TestApplyHitResultOnKilled()
         {
             ManualClock clock = null;
-            bool anyJudged = false;
-
-            void onNewResult(JudgementResult _) => anyJudged = true;
 
             var beatmap = new Beatmap();
             beatmap.HitObjects.Add(new TestKilledHitObject { Duration = 20 });
 
             createTest(beatmap, 10, () => new FramedClock(clock = new ManualClock()));
 
-            AddStep("subscribe to new result", () =>
-            {
-                anyJudged = false;
-                drawableRuleset.NewResult += onNewResult;
-            });
             AddStep("skip past object", () => clock.CurrentTime = beatmap.HitObjects[0].GetEndTime() + 1000);
 
-            AddAssert("object judged", () => anyJudged);
-
-            AddStep("clean up", () => drawableRuleset.NewResult -= onNewResult);
+            AddAssert("object judged", () => playfield.JudgedObjects.Count == 1);
         }
 
         private void createTest(IBeatmap beatmap, int poolSize, Func<IFrameBasedClock> createClock = null)
@@ -212,12 +233,24 @@ namespace osu.Game.Tests.Visual.Gameplay
 
         private partial class TestPlayfield : Playfield
         {
+            public readonly HashSet<HitObject> JudgedObjects = new HashSet<HitObject>();
+
             private readonly int poolSize;
 
             public TestPlayfield(int poolSize)
             {
                 this.poolSize = poolSize;
                 AddInternal(HitObjectContainer);
+                NewResult += (_, r) =>
+                {
+                    Assert.That(JudgedObjects, Has.No.Member(r.HitObject));
+                    JudgedObjects.Add(r.HitObject);
+                };
+                RevertResult += r =>
+                {
+                    Assert.That(JudgedObjects, Has.Member(r.HitObject));
+                    JudgedObjects.Remove(r.HitObject);
+                };
             }
 
             [BackgroundDependencyLoader]

From e66e43e17ce3330f5924738a28de44f6593c2bc2 Mon Sep 17 00:00:00 2001
From: ekrctb <ekrctb@gmail.com>
Date: Tue, 24 Jan 2023 14:15:17 +0900
Subject: [PATCH 04/11] Remove unused code

---
 osu.Game/Rulesets/Judgements/JudgementResultEntry.cs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs b/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs
index c3f44804c3..b9d75d3acb 100644
--- a/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs
+++ b/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs
@@ -1,12 +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 System;
 using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Judgements
 {
-    internal class JudgementResultEntry : IComparable<JudgementResultEntry>
+    internal class JudgementResultEntry
     {
         public readonly double Time;
 
@@ -20,7 +19,5 @@ namespace osu.Game.Rulesets.Judgements
             HitObjectEntry = hitObjectEntry;
             Result = result;
         }
-
-        public int CompareTo(JudgementResultEntry? other) => Time.CompareTo(other?.Time);
     }
 }
\ No newline at end of file

From cc87923179ccaa9533be0a2501e31f95e6aba6c8 Mon Sep 17 00:00:00 2001
From: ekrctb <ekrctb@gmail.com>
Date: Tue, 24 Jan 2023 14:19:24 +0900
Subject: [PATCH 05/11] Fix OnRevertResult timing

---
 osu.Game/Rulesets/UI/Playfield.cs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/osu.Game/Rulesets/UI/Playfield.cs b/osu.Game/Rulesets/UI/Playfield.cs
index 9535ebb9ed..1d9390ea14 100644
--- a/osu.Game/Rulesets/UI/Playfield.cs
+++ b/osu.Game/Rulesets/UI/Playfield.cs
@@ -464,11 +464,10 @@ namespace osu.Game.Rulesets.UI
         {
             var result = entry.Result;
             RevertResult?.Invoke(result);
+            entry.HitObjectEntry.OnRevertResult();
 
             result.TimeOffset = 0;
             result.Type = HitResult.None;
-
-            entry.HitObjectEntry.OnRevertResult();
         }
 
         #region Editor logic

From efef97d5be5f9bcf38c67713c572f3e48c0c5625 Mon Sep 17 00:00:00 2001
From: ekrctb <ekrctb@gmail.com>
Date: Tue, 24 Jan 2023 15:35:06 +0900
Subject: [PATCH 06/11] Store Result.TimeAbsolute separately from offset
 Calculating from TimeOffset is bad because it loses precision. The result
 time won't change anymore even If `HitObject.GetEndTime()` changes later.

---
 osu.Game/Rulesets/Judgements/JudgementResult.cs | 17 ++++++++++++++---
 .../Rulesets/Judgements/JudgementResultEntry.cs |  5 ++---
 .../Objects/Drawables/DrawableHitObject.cs      |  3 ++-
 osu.Game/Rulesets/UI/Playfield.cs               |  5 ++---
 4 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/osu.Game/Rulesets/Judgements/JudgementResult.cs b/osu.Game/Rulesets/Judgements/JudgementResult.cs
index 2685cb4e2a..9fdbdae396 100644
--- a/osu.Game/Rulesets/Judgements/JudgementResult.cs
+++ b/osu.Game/Rulesets/Judgements/JudgementResult.cs
@@ -33,16 +33,19 @@ namespace osu.Game.Rulesets.Judgements
         public readonly Judgement Judgement;
 
         /// <summary>
-        /// The offset from a perfect hit at which this <see cref="JudgementResult"/> occurred.
+        /// The offset of <see cref="TimeAbsolute"/> from the end time of <see cref="HitObject"/>, clamped by <see cref="DrawableHitObject.MaximumJudgementOffset"/>.
         /// Populated when this <see cref="JudgementResult"/> is applied via <see cref="DrawableHitObject.ApplyResult"/>.
         /// </summary>
         public double TimeOffset { get; internal set; }
 
         /// <summary>
         /// The absolute time at which this <see cref="JudgementResult"/> occurred.
-        /// Equal to the (end) time of the <see cref="HitObject"/> + <see cref="TimeOffset"/>.
+        /// Populated when this <see cref="JudgementResult"/> is applied via <see cref="DrawableHitObject.ApplyResult"/>.
         /// </summary>
-        public double TimeAbsolute => HitObject.GetEndTime() + TimeOffset;
+        /// <remarks>
+        /// This is initially set to the end time of <see cref="HitObject"/>.
+        /// </remarks>
+        public double TimeAbsolute { get; internal set; }
 
         /// <summary>
         /// The combo prior to this <see cref="JudgementResult"/> occurring.
@@ -83,6 +86,14 @@ namespace osu.Game.Rulesets.Judgements
         {
             HitObject = hitObject;
             Judgement = judgement;
+            Reset();
+        }
+
+        internal void Reset()
+        {
+            Type = HitResult.None;
+            TimeOffset = 0;
+            TimeAbsolute = HitObject.GetEndTime();
         }
 
         public override string ToString() => $"{Type} (Score:{Judgement.NumericResultFor(this)} HP:{Judgement.HealthIncreaseFor(this)} {Judgement})";
diff --git a/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs b/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs
index b9d75d3acb..09351e6974 100644
--- a/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs
+++ b/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs
@@ -7,15 +7,14 @@ namespace osu.Game.Rulesets.Judgements
 {
     internal class JudgementResultEntry
     {
-        public readonly double Time;
+        public double Time => Result.TimeAbsolute;
 
         public readonly HitObjectLifetimeEntry HitObjectEntry;
 
         public readonly JudgementResult Result;
 
-        public JudgementResultEntry(double time, HitObjectLifetimeEntry hitObjectEntry, JudgementResult result)
+        public JudgementResultEntry(HitObjectLifetimeEntry hitObjectEntry, JudgementResult result)
         {
-            Time = time;
             HitObjectEntry = hitObjectEntry;
             Result = result;
         }
diff --git a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
index 02fc5637d8..0c59d638b6 100644
--- a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
+++ b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
@@ -673,7 +673,8 @@ namespace osu.Game.Rulesets.Objects.Drawables
                     $"{GetType().ReadableName()} applied an invalid hit result (was: {Result.Type}, expected: [{Result.Judgement.MinResult} ... {Result.Judgement.MaxResult}]).");
             }
 
-            Result.TimeOffset = Math.Min(MaximumJudgementOffset, Time.Current - HitObject.GetEndTime());
+            Result.TimeAbsolute = Time.Current;
+            Result.TimeOffset = Math.Min(MaximumJudgementOffset, Result.TimeAbsolute - HitObject.GetEndTime());
 
             if (Result.HasResult)
                 updateState(Result.IsHit ? ArmedState.Hit : ArmedState.Miss);
diff --git a/osu.Game/Rulesets/UI/Playfield.cs b/osu.Game/Rulesets/UI/Playfield.cs
index 1d9390ea14..40e84a60e3 100644
--- a/osu.Game/Rulesets/UI/Playfield.cs
+++ b/osu.Game/Rulesets/UI/Playfield.cs
@@ -455,7 +455,7 @@ namespace osu.Game.Rulesets.UI
         private void onNewResult(DrawableHitObject drawable, JudgementResult result)
         {
             // Not using result.TimeAbsolute because that might change and also there is a potential precision issue.
-            judgementResults.Push(new JudgementResultEntry(Time.Current, drawable.Entry.AsNonNull(), result));
+            judgementResults.Push(new JudgementResultEntry(drawable.Entry.AsNonNull(), result));
 
             NewResult?.Invoke(drawable, result);
         }
@@ -466,8 +466,7 @@ namespace osu.Game.Rulesets.UI
             RevertResult?.Invoke(result);
             entry.HitObjectEntry.OnRevertResult();
 
-            result.TimeOffset = 0;
-            result.Type = HitResult.None;
+            result.Reset();
         }
 
         #region Editor logic

From e1702a8ee9d50cf15f1a2cd02a64d03a245a0d3f Mon Sep 17 00:00:00 2001
From: ekrctb <ekrctb@gmail.com>
Date: Tue, 24 Jan 2023 15:43:57 +0900
Subject: [PATCH 07/11] Fix inspection issue

---
 osu.Game/Rulesets/UI/Playfield.cs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/osu.Game/Rulesets/UI/Playfield.cs b/osu.Game/Rulesets/UI/Playfield.cs
index 40e84a60e3..3ec31db4b9 100644
--- a/osu.Game/Rulesets/UI/Playfield.cs
+++ b/osu.Game/Rulesets/UI/Playfield.cs
@@ -22,7 +22,6 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Skinning;
 using osuTK;
 using osu.Game.Rulesets.Objects.Pooling;
-using osu.Game.Rulesets.Scoring;
 using osu.Framework.Extensions.ObjectExtensions;
 
 namespace osu.Game.Rulesets.UI

From e3a5c233e9b8510e6e199eeabf39de0ad8a5145b Mon Sep 17 00:00:00 2001
From: Dean Herbert <pe@ppy.sh>
Date: Wed, 25 Jan 2023 17:39:35 +0900
Subject: [PATCH 08/11] Update test to use newer assetion logic

---
 osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs b/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
index 22ab74cc30..0469df1de3 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestScenePoolingRuleset.cs
@@ -151,17 +151,17 @@ namespace osu.Game.Tests.Visual.Gameplay
             }, 10, () => new FramedClock(clock = new ManualClock()));
 
             AddStep("fast forward to end", () => clock.CurrentTime = beatmap.HitObjects[^1].GetEndTime() + 100);
-            AddUntilStep("all judged", () => playfield.JudgedObjects.Count == 3);
+            AddUntilStep("all judged", () => playfield.JudgedObjects.Count, () => Is.EqualTo(3));
 
             AddStep("rewind to middle", () => clock.CurrentTime = beatmap.HitObjects[1].StartTime - 100);
-            AddUntilStep("some results reverted", () => playfield.JudgedObjects.Count == 1);
+            AddUntilStep("some results reverted", () => playfield.JudgedObjects.Count, () => Is.EqualTo(1));
 
             AddStep("fast forward to end", () => clock.CurrentTime = beatmap.HitObjects[^1].GetEndTime() + 100);
-            AddUntilStep("all judged", () => playfield.JudgedObjects.Count == 3);
+            AddUntilStep("all judged", () => playfield.JudgedObjects.Count, () => Is.EqualTo(3));
 
             AddStep("disable frame stability", () => drawableRuleset.FrameStablePlayback = false);
             AddStep("instant seek to start", () => clock.CurrentTime = beatmap.HitObjects[0].StartTime - 100);
-            AddAssert("all results reverted", () => playfield.JudgedObjects.Count == 0);
+            AddAssert("all results reverted", () => playfield.JudgedObjects.Count, () => Is.EqualTo(0));
         }
 
         [Test]

From 27578c48f5fd43a42cde43acb290c10dac9c3fe4 Mon Sep 17 00:00:00 2001
From: ekrctb <ekrctb@gmail.com>
Date: Fri, 27 Jan 2023 19:35:44 +0900
Subject: [PATCH 09/11] Remove JudgementResultEntry It is not needed anymore as
 TimeAbsolute is stored raw.

---
 .../Judgements/JudgementResultEntry.cs        | 22 -------------------
 osu.Game/Rulesets/UI/Playfield.cs             | 18 ++++++++-------
 2 files changed, 10 insertions(+), 30 deletions(-)
 delete mode 100644 osu.Game/Rulesets/Judgements/JudgementResultEntry.cs

diff --git a/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs b/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs
deleted file mode 100644
index 09351e6974..0000000000
--- a/osu.Game/Rulesets/Judgements/JudgementResultEntry.cs
+++ /dev/null
@@ -1,22 +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.Objects;
-
-namespace osu.Game.Rulesets.Judgements
-{
-    internal class JudgementResultEntry
-    {
-        public double Time => Result.TimeAbsolute;
-
-        public readonly HitObjectLifetimeEntry HitObjectEntry;
-
-        public readonly JudgementResult Result;
-
-        public JudgementResultEntry(HitObjectLifetimeEntry hitObjectEntry, JudgementResult result)
-        {
-            HitObjectEntry = hitObjectEntry;
-            Result = result;
-        }
-    }
-}
\ No newline at end of file
diff --git a/osu.Game/Rulesets/UI/Playfield.cs b/osu.Game/Rulesets/UI/Playfield.cs
index 3ec31db4b9..5d6a8de33c 100644
--- a/osu.Game/Rulesets/UI/Playfield.cs
+++ b/osu.Game/Rulesets/UI/Playfield.cs
@@ -99,7 +99,7 @@ namespace osu.Game.Rulesets.UI
 
         private readonly HitObjectEntryManager entryManager = new HitObjectEntryManager();
 
-        private readonly Stack<JudgementResultEntry> judgementResults;
+        private readonly Stack<HitObjectLifetimeEntry> judgedEntries;
 
         /// <summary>
         /// Creates a new <see cref="Playfield"/>.
@@ -118,7 +118,7 @@ namespace osu.Game.Rulesets.UI
             entryManager.OnEntryAdded += onEntryAdded;
             entryManager.OnEntryRemoved += onEntryRemoved;
 
-            judgementResults = new Stack<JudgementResultEntry>();
+            judgedEntries = new Stack<HitObjectLifetimeEntry>();
         }
 
         [BackgroundDependencyLoader]
@@ -258,8 +258,8 @@ namespace osu.Game.Rulesets.UI
             }
 
             // When rewinding, revert future judgements in the reverse order.
-            while (judgementResults.Count > 0 && Time.Current < judgementResults.Peek().Time)
-                revertResult(judgementResults.Pop());
+            while (judgedEntries.Count > 0 && Time.Current < judgedEntries.Peek().Result.AsNonNull().TimeAbsolute)
+                revertResult(judgedEntries.Pop());
         }
 
         /// <summary>
@@ -453,17 +453,19 @@ namespace osu.Game.Rulesets.UI
 
         private void onNewResult(DrawableHitObject drawable, JudgementResult result)
         {
-            // Not using result.TimeAbsolute because that might change and also there is a potential precision issue.
-            judgementResults.Push(new JudgementResultEntry(drawable.Entry.AsNonNull(), result));
+            Debug.Assert(result != null && drawable.Entry?.Result == result);
+            judgedEntries.Push(drawable.Entry.AsNonNull());
 
             NewResult?.Invoke(drawable, result);
         }
 
-        private void revertResult(JudgementResultEntry entry)
+        private void revertResult(HitObjectLifetimeEntry entry)
         {
             var result = entry.Result;
+            Debug.Assert(result != null);
+
             RevertResult?.Invoke(result);
-            entry.HitObjectEntry.OnRevertResult();
+            entry.OnRevertResult();
 
             result.Reset();
         }

From 258de3b2d89cc2a7a4a624202c8460be89e83638 Mon Sep 17 00:00:00 2001
From: ekrctb <ekrctb@gmail.com>
Date: Thu, 9 Feb 2023 17:15:37 +0900
Subject: [PATCH 10/11] Store RawTime in JudgementResult

---
 .../Rulesets/Judgements/JudgementResult.cs    | 33 ++++++++++++-------
 .../Objects/Drawables/DrawableHitObject.cs    |  2 +-
 osu.Game/Rulesets/UI/Playfield.cs             | 12 +++++--
 3 files changed, 33 insertions(+), 14 deletions(-)

diff --git a/osu.Game/Rulesets/Judgements/JudgementResult.cs b/osu.Game/Rulesets/Judgements/JudgementResult.cs
index 6749fd7932..bf29919e34 100644
--- a/osu.Game/Rulesets/Judgements/JudgementResult.cs
+++ b/osu.Game/Rulesets/Judgements/JudgementResult.cs
@@ -3,6 +3,7 @@
 
 #nullable disable
 
+using System;
 using JetBrains.Annotations;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
@@ -33,19 +34,30 @@ namespace osu.Game.Rulesets.Judgements
         public readonly Judgement Judgement;
 
         /// <summary>
-        /// The offset of <see cref="TimeAbsolute"/> from the end time of <see cref="HitObject"/>, clamped by <see cref="HitObject.MaximumJudgementOffset"/>.
-        /// Populated when this <see cref="JudgementResult"/> is applied via <see cref="DrawableHitObject.ApplyResult"/>.
-        /// </summary>
-        public double TimeOffset { get; internal set; }
-
-        /// <summary>
-        /// The absolute time at which this <see cref="JudgementResult"/> occurred.
+        /// The time at which this <see cref="JudgementResult"/> occurred.
         /// Populated when this <see cref="JudgementResult"/> is applied via <see cref="DrawableHitObject.ApplyResult"/>.
         /// </summary>
         /// <remarks>
-        /// This is initially set to the end time of <see cref="HitObject"/>.
+        /// This is used instead of <see cref="TimeAbsolute"/> to check whether this <see cref="JudgementResult"/> should be reverted.
         /// </remarks>
-        public double TimeAbsolute { get; internal set; }
+        internal double? RawTime { get; set; }
+
+        /// <summary>
+        /// The offset of <see cref="TimeAbsolute"/> from the end time of <see cref="HitObject"/>, clamped by <see cref="osu.Game.Rulesets.Objects.HitObject.MaximumJudgementOffset"/>.
+        /// </summary>
+        public double TimeOffset
+        {
+            get => RawTime != null ? Math.Min(RawTime.Value - HitObject.GetEndTime(), HitObject.MaximumJudgementOffset) : 0;
+            internal set => RawTime = HitObject.GetEndTime() + value;
+        }
+
+        /// <summary>
+        /// The absolute time at which this <see cref="JudgementResult"/> occurred, clamped by the end time of <see cref="HitObject"/> plus <see cref="osu.Game.Rulesets.Objects.HitObject.MaximumJudgementOffset"/>.
+        /// </summary>
+        /// <remarks>
+        /// The end time of <see cref="HitObject"/> is returned if this result is not populated yet.
+        /// </remarks>
+        public double TimeAbsolute => RawTime != null ? Math.Min(RawTime.Value, HitObject.GetEndTime() + HitObject.MaximumJudgementOffset) : HitObject.GetEndTime();
 
         /// <summary>
         /// The combo prior to this <see cref="JudgementResult"/> occurring.
@@ -92,8 +104,7 @@ namespace osu.Game.Rulesets.Judgements
         internal void Reset()
         {
             Type = HitResult.None;
-            TimeOffset = 0;
-            TimeAbsolute = HitObject.GetEndTime();
+            RawTime = null;
         }
 
         public override string ToString() => $"{Type} (Score:{Judgement.NumericResultFor(this)} HP:{Judgement.HealthIncreaseFor(this)} {Judgement})";
diff --git a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
index d30fc00bfc..f7c6340419 100644
--- a/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
+++ b/osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs
@@ -661,7 +661,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
                     $"{GetType().ReadableName()} applied an invalid hit result (was: {Result.Type}, expected: [{Result.Judgement.MinResult} ... {Result.Judgement.MaxResult}]).");
             }
 
-            Result.TimeOffset = Math.Min(HitObject.MaximumJudgementOffset, Time.Current - HitObject.GetEndTime());
+            Result.RawTime = Time.Current;
 
             if (Result.HasResult)
                 updateState(Result.IsHit ? ArmedState.Hit : ArmedState.Miss);
diff --git a/osu.Game/Rulesets/UI/Playfield.cs b/osu.Game/Rulesets/UI/Playfield.cs
index 5d6a8de33c..b1c3b78e67 100644
--- a/osu.Game/Rulesets/UI/Playfield.cs
+++ b/osu.Game/Rulesets/UI/Playfield.cs
@@ -258,8 +258,16 @@ namespace osu.Game.Rulesets.UI
             }
 
             // When rewinding, revert future judgements in the reverse order.
-            while (judgedEntries.Count > 0 && Time.Current < judgedEntries.Peek().Result.AsNonNull().TimeAbsolute)
+            while (judgedEntries.Count > 0)
+            {
+                var result = judgedEntries.Peek().Result;
+                Debug.Assert(result?.RawTime != null);
+
+                if (Time.Current >= result.RawTime.Value)
+                    break;
+
                 revertResult(judgedEntries.Pop());
+            }
         }
 
         /// <summary>
@@ -453,7 +461,7 @@ namespace osu.Game.Rulesets.UI
 
         private void onNewResult(DrawableHitObject drawable, JudgementResult result)
         {
-            Debug.Assert(result != null && drawable.Entry?.Result == result);
+            Debug.Assert(result != null && drawable.Entry?.Result == result && result.RawTime != null);
             judgedEntries.Push(drawable.Entry.AsNonNull());
 
             NewResult?.Invoke(drawable, result);

From 5ddaf8ea3c2d0f79f891a1a8672e534e3e2dc13e Mon Sep 17 00:00:00 2001
From: ekrctb <ekrctb@gmail.com>
Date: Thu, 9 Feb 2023 17:43:04 +0900
Subject: [PATCH 11/11] Fix test setting invalid TimeOffset

---
 .../Visual/Gameplay/TestSceneUnstableRateCounter.cs       | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/osu.Game.Tests/Visual/Gameplay/TestSceneUnstableRateCounter.cs b/osu.Game.Tests/Visual/Gameplay/TestSceneUnstableRateCounter.cs
index 2f572b46c9..d0e516ed39 100644
--- a/osu.Game.Tests/Visual/Gameplay/TestSceneUnstableRateCounter.cs
+++ b/osu.Game.Tests/Visual/Gameplay/TestSceneUnstableRateCounter.cs
@@ -22,12 +22,18 @@ namespace osu.Game.Tests.Visual.Gameplay
         [Cached(typeof(ScoreProcessor))]
         private TestScoreProcessor scoreProcessor = new TestScoreProcessor();
 
-        private readonly OsuHitWindows hitWindows = new OsuHitWindows();
+        private readonly OsuHitWindows hitWindows;
 
         private UnstableRateCounter counter;
 
         private double prev;
 
+        public TestSceneUnstableRateCounter()
+        {
+            hitWindows = new OsuHitWindows();
+            hitWindows.SetDifficulty(5);
+        }
+
         [SetUpSteps]
         public void SetUp()
         {