Merge pull request #1453 from smoogipoo/replay-rewinding

Implement the necessary interfaces to allow replay rewinding

osu-framework

@@ -1 +1 @@
-Subproject commit 5e26808ec77a8fd600cb1cdca3a4b2f62fd0c653
+Subproject commit 1a563d7ce0834cede2ef587762f98fe580badf3c

osu-resources

@@ -1 +1 @@
-Subproject commit 1750ab8f6761ab35592fd46da71fbe0c141bfd93
+Subproject commit a4418111f8ed2350a6fd46fe69258884f0757745

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

@@ -94,7 +94,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
 
         protected override void UpdateState(ArmedState state)
         {
-            switch (State)
+            switch (State.Value)
             {
                 case ArmedState.Hit:
                     AccentColour = Color4.Green;

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

@@ -57,8 +57,10 @@ namespace osu.Game.Rulesets.Mania.UI
         {
             base.LoadComplete();
 
-            this.ScaleTo(2f, 600, Easing.OutQuint).FadeOut(500).Expire();
+            this.ScaleTo(2f, 600, Easing.OutQuint).FadeOut(500);
             inner.FadeOut(250);
+
+            Expire(true);
         }
     }
 }

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

@@ -14,6 +14,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
     {
         private const float width = 8;
 
+        public override bool RemoveWhenNotAlive => false;
+
         public FollowPoint()
         {
             Origin = Anchor.Centre;

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

@@ -52,9 +52,12 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
             }
         }
 
+        public override bool RemoveCompletedTransforms => false;
+
         private void update()
         {
             Clear();
+
             if (hitObjects == null)
                 return;
 

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

@@ -58,6 +58,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 },
                 ApproachCircle = new ApproachCircle
                 {
+                    Alpha = 0,
+                    Scale = new Vector2(4),
                     Colour = AccentColour,
                 }
             };
@@ -82,21 +84,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             });
         }
 
-        protected override void UpdateInitialState()
-        {
-            base.UpdateInitialState();
-
-            // sane defaults
-            ring.Show();
-            circle.Show();
-            number.Show();
-            glow.Show();
-
-            ApproachCircle.Hide();
-            ApproachCircle.ScaleTo(new Vector2(4));
-            explode.Hide();
-        }
-
         protected override void UpdatePreemptState()
         {
             base.UpdatePreemptState();

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

@@ -23,12 +23,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         protected sealed override void UpdateState(ArmedState state)
         {
-            FinishTransforms();
+            double transformTime = HitObject.StartTime - TIME_PREEMPT;
 
-            using (BeginAbsoluteSequence(HitObject.StartTime - TIME_PREEMPT, true))
+            base.ApplyTransformsAt(transformTime, true);
+            base.ClearTransformsAfter(transformTime, true);
+
+            using (BeginAbsoluteSequence(transformTime, true))
             {
-                UpdateInitialState();
-
                 UpdatePreemptState();
 
                 using (BeginDelayedSequence(TIME_PREEMPT + (Judgements.FirstOrDefault()?.TimeOffset ?? 0), true))
@@ -36,11 +37,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
         }
 
-        protected virtual void UpdateInitialState()
-        {
-            Hide();
-        }
-
         protected virtual void UpdatePreemptState()
         {
             this.FadeIn(TIME_FADEIN);
@@ -50,6 +46,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
         }
 
+        // Todo: At some point we need to move these to DrawableHitObject after ensuring that all other Rulesets apply
+        // transforms in the same way and don't rely on them not being cleared
+        public override void ClearTransformsAfter(double time, bool propagateChildren = false, string targetMember = null) { }
+        public override void ApplyTransformsAt(double time, bool propagateChildren = false) { }
+
         private OsuInputManager osuActionInputManager;
         internal OsuInputManager OsuActionInputManager => osuActionInputManager ?? (osuActionInputManager = GetContainingInputManager() as OsuInputManager);
     }

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

@@ -18,9 +18,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         public double FadeInTime;
         public double FadeOutTime;
 
-        public override bool RemoveWhenNotAlive => false;
+        public DrawableRepeatPoint(RepeatPoint repeatPoint, DrawableSlider drawableSlider)
-
+            : base(repeatPoint)
-        public DrawableRepeatPoint(RepeatPoint repeatPoint, DrawableSlider drawableSlider) : base(repeatPoint)
         {
             this.repeatPoint = repeatPoint;
             this.drawableSlider = drawableSlider;
@@ -28,6 +27,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             AutoSizeAxes = Axes.Both;
             Blending = BlendingMode.Additive;
             Origin = Anchor.Centre;
+            Scale = new Vector2(0.5f);
 
             Children = new Drawable[]
             {
@@ -51,12 +51,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             var animIn = Math.Min(150, repeatPoint.StartTime - FadeInTime);
 
-            this.Animate(
+            this.FadeIn(animIn).ScaleTo(1.2f, animIn)
-                d => d.FadeIn(animIn),
+                .Then()
-                d => d.ScaleTo(0.5f).ScaleTo(1.2f, animIn)
+                .ScaleTo(1, 150, Easing.Out);
-            ).Then(
-                d => d.ScaleTo(1, 150, Easing.Out)
-            );
         }
 
         protected override void UpdateCurrentState(ArmedState state)

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

@@ -43,7 +43,9 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 ball = new SliderBall(s)
                 {
                     Scale = new Vector2(s.Scale),
-                    AccentColour = AccentColour
+                    AccentColour = AccentColour,
+                    AlwaysPresent = true,
+                    Alpha = 0
                 },
                 initialCircle = new DrawableHitCircle(new HitCircle
                 {
@@ -148,16 +150,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
         }
 
-        protected override void UpdateInitialState()
-        {
-            base.UpdateInitialState();
-            body.Alpha = 1;
-
-            //we need to be present to handle input events. note that we still don't get enough events (we don't get a position if the mouse hasn't moved since the slider appeared).
-            ball.AlwaysPresent = true;
-            ball.Alpha = 0;
-        }
-
         protected override void UpdateCurrentState(ArmedState state)
         {
             ball.FadeIn();

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

@@ -20,8 +20,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public bool Tracking;
 
-        public override bool RemoveWhenNotAlive => false;
-
         public override bool DisplayJudgement => false;
 
         public DrawableSliderTick(SliderTick sliderTick) : base(sliderTick)

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SliderBall.cs

@@ -101,14 +101,21 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
         // If the current time is between the start and end of the slider, we should track mouse input regardless of the cursor position.
         public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => canCurrentlyTrack || base.ReceiveMouseInputAt(screenSpacePos);
 
+        public override void ClearTransforms(bool propagateChildren = false, string targetMember = null)
+        {
+            // Consider the case of rewinding - children's transforms are handled internally, so propagating down
+            // any further will cause weirdness with the Tracking bool below. Let's not propagate further at this point.
+            base.ClearTransforms(false, targetMember);
+        }
+
         private bool tracking;
         public bool Tracking
         {
             get { return tracking; }
             private set
             {
-                if (value == tracking) return;
+                if (value == tracking)
-
+                    return;
                 tracking = value;
 
                 follow.ScaleTo(tracking ? 2.8f : 1, 300, Easing.OutQuint);
@@ -123,8 +130,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             base.Update();
 
             // Make sure to use the base version of ReceiveMouseInputAt so that we correctly check the position.
-            if (Time.Current < slider.EndTime)
+            Tracking = canCurrentlyTrack
-                Tracking = canCurrentlyTrack && lastState != null && base.ReceiveMouseInputAt(lastState.Mouse.NativeState.Position) && ((Parent as DrawableSlider)?.OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false);
+                        && lastState != null
+                        && base.ReceiveMouseInputAt(lastState.Mouse.NativeState.Position)
+                        && ((Parent as DrawableSlider)?.OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false);
         }
 
         public void UpdateProgress(double progress, int repeat)

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerSpmCounter.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
@@ -61,6 +62,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
 
         public void SetRotation(float currentRotation)
         {
+            // If we've gone back in time, it's fine to work with a fresh set of records for now
+            if (records.Count > 0 && Time.Current < records.Last().Time)
+                records.Clear();
+
             if (records.Count > 0)
             {
                 var record = records.Peek();

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

@@ -111,7 +111,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             h.Depth = depth++;
 
             if (auto)
-                h.State = ArmedState.Hit;
+                h.State.Value = ArmedState.Hit;
 
             playfieldContainer.Add(h);
             var proxyable = h as IDrawableHitObjectWithProxiedApproach;

osu.Game.Rulesets.Taiko/Judgements/TaikoStrongHitJudgement.cs

@@ -1,8 +1,6 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Game.Rulesets.Objects.Drawables;
-
 namespace osu.Game.Rulesets.Taiko.Judgements
 {
     public class TaikoStrongHitJudgement : TaikoJudgement
@@ -11,9 +9,7 @@ namespace osu.Game.Rulesets.Taiko.Judgements
 
         public TaikoStrongHitJudgement()
         {
-            base.Result = HitResult.Perfect;
+            Final = true;
         }
-
-        public new HitResult Result => base.Result;
     }
 }

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

@@ -17,6 +17,11 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         /// </summary>
         protected abstract TaikoAction[] HitActions { get; }
 
+        /// <summary>
+        /// Whether a second hit is allowed to be processed. This occurs once this hit object has been hit successfully.
+        /// </summary>
+        protected bool SecondHitAllowed { get; private set; }
+
         /// <summary>
         /// Whether the last key pressed is a valid hit key.
         /// </summary>
@@ -45,7 +50,15 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             if (!validKeyPressed)
                 AddJudgement(new TaikoJudgement { Result = HitResult.Miss });
             else if (hitOffset < HitObject.HitWindowGood)
-                AddJudgement(new TaikoJudgement { Result = hitOffset < HitObject.HitWindowGreat ? HitResult.Great : HitResult.Good });
+            {
+                AddJudgement(new TaikoJudgement
+                {
+                    Result = hitOffset < HitObject.HitWindowGreat ? HitResult.Great : HitResult.Good,
+                    Final = !HitObject.IsStrong
+                });
+
+                SecondHitAllowed = true;
+            }
             else
                 AddJudgement(new TaikoJudgement { Result = HitResult.Miss });
         }
@@ -72,7 +85,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
             var offset = !AllJudged ? 0 : Time.Current - HitObject.StartTime;
             using (BeginDelayedSequence(HitObject.StartTime - Time.Current + offset, true))
             {
-                switch (State)
+                switch (State.Value)
                 {
                     case ArmedState.Idle:
                         this.Delay(HitObject.HitWindowMiss).Expire();

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

@@ -3,6 +3,7 @@
 
 using System;
 using System.Linq;
+using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Judgements;
 
 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
@@ -24,27 +25,25 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
         {
         }
 
-        private bool processedSecondHit;
-        public override bool AllJudged => processedSecondHit && base.AllJudged;
-
         protected override void CheckForJudgements(bool userTriggered, double timeOffset)
         {
-            if (!base.AllJudged)
+            if (!SecondHitAllowed)
             {
                 base.CheckForJudgements(userTriggered, timeOffset);
                 return;
             }
 
             if (!userTriggered)
+            {
+                if (timeOffset > second_hit_window)
+                    AddJudgement(new TaikoStrongHitJudgement { Result = HitResult.Miss });
                 return;
+            }
 
             // If we get here, we're assured that the key pressed is the correct secondary key
 
             if (Math.Abs(firstHitTime - Time.Current) < second_hit_window)
-            {
+                AddJudgement(new TaikoStrongHitJudgement { Result = HitResult.Great });
-                AddJudgement(new TaikoStrongHitJudgement());
-                processedSecondHit = true;
-            }
         }
 
         public override bool OnReleased(TaikoAction action)
@@ -56,8 +55,11 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 
         public override bool OnPressed(TaikoAction action)
         {
+            if (AllJudged)
+                return false;
+
             // Check if we've handled the first key
-            if (!base.AllJudged)
+            if (!SecondHitAllowed)
             {
                 // First key hasn't been handled yet, attempt to handle it
                 bool handled = base.OnPressed(action);
@@ -72,10 +74,6 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                 return handled;
             }
 
-            // If we've already hit the second key, don't handle this object any further
-            if (processedSecondHit)
-                return false;
-
             // Don't handle represses of the first key
             if (firstHitAction == action)
                 return false;

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

@@ -244,7 +244,12 @@ namespace osu.Game.Rulesets.Taiko.UI
                 if (judgedObject.X >= -0.05f && judgedObject is DrawableHit)
                 {
                     // If we're far enough away from the left stage, we should bring outselves in front of it
-                    topLevelHitContainer.Add(judgedObject.CreateProxy());
+                    // Todo: The following try-catch is temporary for replay rewinding support
+                    try
+                    {
+                        topLevelHitContainer.Add(judgedObject.CreateProxy());
+                    }
+                    catch { }
                 }
 
                 hitExplosionContainer.Add(new HitExplosion(judgedObject, isRim));

osu.Game/Graphics/Sprites/OsuSpriteText.cs

@@ -6,6 +6,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
 using OpenTK;
 using OpenTK.Graphics;
+using osu.Framework.Graphics.Transforms;
 
 namespace osu.Game.Graphics.Sprites
 {
@@ -40,4 +41,23 @@ namespace osu.Game.Graphics.Sprites
             return base.CreateFallbackCharacterDrawable();
         }
     }
+
+    public static class OsuSpriteTextTransformExtensions
+    {
+        /// <summary>
+        /// Sets <see cref="OsuSpriteText.Text"/> to a new value after a duration.
+        /// </summary>
+        /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns>
+        public static TransformSequence<T> TransformTextTo<T>(this T spriteText, string newText, double duration = 0, Easing easing = Easing.None)
+            where T : OsuSpriteText
+            => spriteText.TransformTo(nameof(OsuSpriteText.Text), newText, duration, easing);
+
+        /// <summary>
+        /// Sets <see cref="OsuSpriteText.Text"/> to a new value after a duration.
+        /// </summary>
+        /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns>
+        public static TransformSequence<T> TransformTextTo<T>(this TransformSequence<T> t, string newText, double duration = 0, Easing easing = Easing.None)
+            where T : OsuSpriteText
+            => t.Append(o => o.TransformTextTo(newText, duration, easing));
+    }
 }

osu.Game/Rulesets/Judgements/DrawableJudgement.cs

@@ -83,7 +83,7 @@ namespace osu.Game.Rulesets.Judgements
                     break;
             }
 
-            Expire();
+            Expire(true);
         }
     }
 }

osu.Game/Rulesets/Judgements/Judgement.cs

@@ -17,8 +17,26 @@ namespace osu.Game.Rulesets.Judgements
         /// </summary>
         public virtual HitResult MaxResult => HitResult.Perfect;
 
+        /// <summary>
+        /// The combo prior to this judgement occurring.
+        /// </summary>
+        internal int ComboAtJudgement;
+
+        /// <summary>
+        /// The highest combo achieved prior to this judgement occurring.
+        /// </summary>
+        internal int HighestComboAtJudgement;
+
+        /// <summary>
+        /// Whether a successful hit occurred.
+        /// </summary>
         public bool IsHit => Result > HitResult.Miss;
 
+        /// <summary>
+        /// Whether this judgement is the final judgement for the hit object.
+        /// </summary>
+        public bool Final = true;
+
         /// <summary>
         /// The offset from a perfect hit at which this judgement occurred.
         /// Populated when added via <see cref="DrawableHitObject{TObject}.AddJudgement"/>.

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

@@ -13,6 +13,7 @@ using OpenTK.Graphics;
 using osu.Game.Audio;
 using System.Linq;
 using osu.Game.Graphics;
+using osu.Framework.Configuration;
 
 namespace osu.Game.Rulesets.Objects.Drawables
 {
@@ -30,6 +31,9 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// </summary>
         public virtual bool DisplayJudgement => true;
 
+        public override bool RemoveCompletedTransforms => false;
+        public override bool RemoveWhenNotAlive => false;
+
         protected DrawableHitObject(HitObject hitObject)
         {
             HitObject = hitObject;
@@ -40,6 +44,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
         where TObject : HitObject
     {
         public event Action<DrawableHitObject, Judgement> OnJudgement;
+        public event Action<DrawableHitObject, Judgement> OnJudgementRemoved;
 
         public new readonly TObject HitObject;
 
@@ -56,31 +61,42 @@ namespace osu.Game.Rulesets.Objects.Drawables
 
         protected List<SampleChannel> Samples = new List<SampleChannel>();
 
+        public readonly Bindable<ArmedState> State = new Bindable<ArmedState>();
+
         protected DrawableHitObject(TObject hitObject)
             : base(hitObject)
         {
             HitObject = hitObject;
         }
 
-        private ArmedState state;
+        [BackgroundDependencyLoader]
-        public ArmedState State
+        private void load(AudioManager audio)
         {
-            get { return state; }
+            foreach (SampleInfo sample in HitObject.Samples)
-
-            set
             {
-                if (state == value)
+                SampleChannel channel = audio.Sample.Get($@"Gameplay/{sample.Bank}-{sample.Name}");
-                    return;
-                state = value;
 
-                if (!IsLoaded)
+                if (channel == null)
-                    return;
+                    continue;
 
+                channel.Volume.Value = sample.Volume;
+                Samples.Add(channel);
+            }
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            State.ValueChanged += state =>
+            {
                 UpdateState(state);
 
                 if (State == ArmedState.Hit)
                     PlaySamples();
-            }
+            };
+
+            State.TriggerChange();
         }
 
         protected void PlaySamples()
@@ -88,21 +104,13 @@ namespace osu.Game.Rulesets.Objects.Drawables
             Samples.ForEach(s => s?.Play());
         }
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
-
-            //force application of the state that was set before we loaded.
-            UpdateState(State);
-        }
-
-        private bool hasJudgementResult;
         private bool judgementOccurred;
+        private bool judgementFinalized => judgements.LastOrDefault()?.Final == true;
 
         /// <summary>
         /// Whether this <see cref="DrawableHitObject"/> and all of its nested <see cref="DrawableHitObject"/>s have been judged.
         /// </summary>
-        public virtual bool AllJudged => (!ProvidesJudgement || hasJudgementResult) && (NestedHitObjects?.All(h => h.AllJudged) ?? true);
+        public bool AllJudged => (!ProvidesJudgement || judgementFinalized) && (NestedHitObjects?.All(h => h.AllJudged) ?? true);
 
         /// <summary>
         /// Notifies that a new judgement has occurred for this <see cref="DrawableHitObject"/>.
@@ -110,7 +118,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// <param name="judgement">The <see cref="Judgement"/>.</param>
         protected void AddJudgement(Judgement judgement)
         {
-            hasJudgementResult = judgement.Result >= HitResult.Miss;
             judgementOccurred = true;
 
             // Ensure that the judgement is given a valid time offset, because this may not get set by the caller
@@ -124,10 +131,10 @@ namespace osu.Game.Rulesets.Objects.Drawables
                 case HitResult.None:
                     break;
                 case HitResult.Miss:
-                    State = ArmedState.Miss;
+                    State.Value = ArmedState.Miss;
                     break;
                 default:
-                    State = ArmedState.Hit;
+                    State.Value = ArmedState.Hit;
                     break;
             }
 
@@ -152,7 +159,7 @@ namespace osu.Game.Rulesets.Objects.Drawables
                     judgementOccurred |= d.UpdateJudgement(userTriggered);
             }
 
-            if (!ProvidesJudgement || hasJudgementResult || judgementOccurred)
+            if (!ProvidesJudgement || judgementFinalized || judgementOccurred)
                 return judgementOccurred;
 
             var endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;
@@ -170,6 +177,25 @@ namespace osu.Game.Rulesets.Objects.Drawables
         /// implies that this check occurred after the end time of <see cref="HitObject"/>. </param>
         protected virtual void CheckForJudgements(bool userTriggered, double timeOffset) { }
 
+        protected override void Update()
+        {
+            base.Update();
+
+            var endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;
+
+            while (judgements.Count > 0)
+            {
+                var lastJudgement = judgements[judgements.Count - 1];
+                if (lastJudgement.TimeOffset + endTime <= Time.Current)
+                    break;
+
+                judgements.RemoveAt(judgements.Count - 1);
+                State.Value = ArmedState.Idle;
+
+                OnJudgementRemoved?.Invoke(this, lastJudgement);
+            }
+        }
+
         protected override void UpdateAfterChildren()
         {
             base.UpdateAfterChildren();
@@ -177,21 +203,6 @@ namespace osu.Game.Rulesets.Objects.Drawables
             UpdateJudgement(false);
         }
 
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
-        {
-            foreach (SampleInfo sample in HitObject.Samples)
-            {
-                SampleChannel channel = audio.Sample.Get($@"Gameplay/{sample.Bank}-{sample.Name}");
-
-                if (channel == null)
-                    continue;
-
-                channel.Volume.Value = sample.Volume;
-                Samples.Add(channel);
-            }
-        }
-
         private List<DrawableHitObject<TObject>> nestedHitObjects;
         protected IEnumerable<DrawableHitObject<TObject>> NestedHitObjects => nestedHitObjects;
 

osu.Game/Rulesets/Replays/FramedReplayInputHandler.cs

@@ -104,7 +104,13 @@ namespace osu.Game.Rulesets.Replays
             {
                 //if we changed frames, we want to execute once *exactly* on the frame's time.
                 if (currentDirection == time.CompareTo(NextFrame.Time) && advanceFrame())
+                {
+                    // If going backwards, we need to execute once _before_ the frame time to reverse any judgements
+                    // that would occur as a result of this frame in forward playback
+                    if (currentDirection == -1)
+                        return currentTime = CurrentFrame.Time - 1;
                     return currentTime = CurrentFrame.Time;
+                }
 
                 //if we didn't change frames, we need to ensure we are allowed to run frames in between, else return null.
                 if (inImportantSection)

osu.Game/Rulesets/Scoring/ScoreProcessor.cs

@@ -174,6 +174,7 @@ namespace osu.Game.Rulesets.Scoring
         private double maxBaseScore;
         private double rollingMaxBaseScore;
         private double baseScore;
+        private double bonusScore;
 
         protected ScoreProcessor()
         {
@@ -184,6 +185,7 @@ namespace osu.Game.Rulesets.Scoring
             Debug.Assert(base_portion + combo_portion == 1.0);
 
             rulesetContainer.OnJudgement += AddJudgement;
+            rulesetContainer.OnJudgementRemoved += RemoveJudgement;
 
             SimulateAutoplay(rulesetContainer.Beatmap);
             Reset(true);
@@ -212,14 +214,26 @@ namespace osu.Game.Rulesets.Scoring
         protected void AddJudgement(Judgement judgement)
         {
             OnNewJudgement(judgement);
-            NotifyNewJudgement(judgement);
+            updateScore();
 
+            NotifyNewJudgement(judgement);
             UpdateFailed();
         }
 
+        protected void RemoveJudgement(Judgement judgement)
+        {
+            OnJudgementRemoved(judgement);
+            updateScore();
+        }
+
+        /// <summary>
+        /// Applies a judgement.
+        /// </summary>
+        /// <param name="judgement">The judgement to apply/</param>
         protected virtual void OnNewJudgement(Judgement judgement)
         {
-            double bonusScore = 0;
+            judgement.ComboAtJudgement = Combo;
+            judgement.HighestComboAtJudgement = HighestCombo;
 
             if (judgement.AffectsCombo)
             {
@@ -242,7 +256,30 @@ namespace osu.Game.Rulesets.Scoring
             }
             else if (judgement.IsHit)
                 bonusScore += judgement.NumericResult;
+        }
 
+        /// <summary>
+        /// Removes a judgement. This should reverse everything in <see cref="OnNewJudgement(Judgement)"/>.
+        /// </summary>
+        /// <param name="judgement">The judgement to remove.</param>
+        protected virtual void OnJudgementRemoved(Judgement judgement)
+        {
+            Combo.Value = judgement.ComboAtJudgement;
+            HighestCombo.Value = judgement.HighestComboAtJudgement;
+
+            if (judgement.AffectsCombo)
+            {
+                baseScore -= judgement.NumericResult;
+                rollingMaxBaseScore -= judgement.MaxNumericResult;
+
+                Hits--;
+            }
+            else if (judgement.IsHit)
+                bonusScore -= judgement.NumericResult;
+        }
+
+        private void updateScore()
+        {
             if (rollingMaxBaseScore != 0)
                 Accuracy.Value = baseScore / rollingMaxBaseScore;
 
@@ -271,6 +308,7 @@ namespace osu.Game.Rulesets.Scoring
             Hits = 0;
             baseScore = 0;
             rollingMaxBaseScore = 0;
+            bonusScore = 0;
         }
     }
 

osu.Game/Rulesets/UI/RulesetContainer.cs

@@ -104,6 +104,7 @@ namespace osu.Game.Rulesets.UI
         where TObject : HitObject
     {
         public event Action<Judgement> OnJudgement;
+        public event Action<Judgement> OnJudgementRemoved;
 
         /// <summary>
         /// The Beatmap
@@ -241,6 +242,8 @@ namespace osu.Game.Rulesets.UI
                     OnJudgement?.Invoke(j);
                 };
 
+                drawableObject.OnJudgementRemoved += (d, j) => { OnJudgementRemoved?.Invoke(j); };
+
                 Playfield.Add(drawableObject);
             }
 

osu.Game/Screens/Play/BreaksOverlay/BreakOverlay.cs

@@ -7,6 +7,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Scoring;
 using System.Collections.Generic;
+using osu.Framework.Graphics.UserInterface;
 
 namespace osu.Game.Screens.Play.BreaksOverlay
 {
@@ -30,6 +31,8 @@ namespace osu.Game.Screens.Play.BreaksOverlay
             }
         }
 
+        public override bool RemoveCompletedTransforms => false;
+
         private readonly bool letterboxing;
         private readonly LetterboxOverlay letterboxOverlay;
         private readonly Container remainingTimeAdjustmentBox;
@@ -101,38 +104,41 @@ namespace osu.Game.Screens.Play.BreaksOverlay
                 if (!b.HasEffect)
                     continue;
 
+                using (BeginAbsoluteSequence(b.StartTime, true))
+                {
+                    remainingTimeAdjustmentBox
+                        .ResizeWidthTo(remaining_time_container_max_size, fade_duration, Easing.OutQuint)
+                        .Delay(b.Duration - fade_duration)
+                        .ResizeWidthTo(0);
+
+                    remainingTimeBox
+                        .ResizeWidthTo(0, b.Duration - fade_duration)
+                        .Then()
+                        .ResizeWidthTo(1);
+
+                    remainingTimeCounter.CountTo(b.Duration).CountTo(0, b.Duration);
+                }
+
                 using (BeginAbsoluteSequence(b.StartTime))
                 {
-                    Schedule(() => onBreakIn(b));
+                    Schedule(showBreak);
                     using (BeginDelayedSequence(b.Duration - fade_duration))
-                        Schedule(onBreakOut);
+                        Schedule(hideBreak);
                 }
             }
         }
 
-        private void onBreakIn(BreakPeriod b)
+        private void showBreak()
         {
             if (letterboxing)
                 letterboxOverlay.Show();
 
-            remainingTimeAdjustmentBox
-                .ResizeWidthTo(remaining_time_container_max_size, fade_duration, Easing.OutQuint)
-                .Delay(b.Duration - fade_duration)
-                .ResizeWidthTo(0);
-
-            remainingTimeBox
-                .ResizeWidthTo(0, b.Duration - fade_duration)
-                .Then()
-                .ResizeWidthTo(1);
-
-            remainingTimeCounter.StartCounting(b.EndTime);
-
             remainingTimeCounter.Show();
             info.Show();
             arrowsOverlay.Show();
         }
 
-        private void onBreakOut()
+        private void hideBreak()
         {
             if (letterboxing)
                 letterboxOverlay.Hide();

osu.Game/Screens/Play/BreaksOverlay/RemainingTimeCounter.cs

@@ -1,65 +1,37 @@
 // Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Framework.Graphics;
 using System;
 using osu.Game.Beatmaps.Timing;
+using osu.Framework.Graphics.UserInterface;
 
 namespace osu.Game.Screens.Play.BreaksOverlay
 {
-    public class RemainingTimeCounter : VisibilityContainer
+    public class RemainingTimeCounter : Counter
     {
         private const double fade_duration = BreakPeriod.MIN_BREAK_DURATION / 2;
 
         private readonly OsuSpriteText counter;
 
-        private int? previousSecond;
-
-        private double endTime;
-
-        private bool isCounting;
-
         public RemainingTimeCounter()
         {
             AutoSizeAxes = Axes.Both;
-            Child = counter = new OsuSpriteText
+            InternalChild = counter = new OsuSpriteText
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 TextSize = 33,
                 Font = "Venera",
             };
+
+            Alpha = 0;
         }
 
-        public void StartCounting(double endTime)
+        protected override void OnCountChanged(double count) => counter.Text = ((int)Math.Ceiling(count / 1000)).ToString();
-        {
-            this.endTime = endTime;
-            isCounting = true;
-        }
 
-        protected override void Update()
+        public override void Show() => this.FadeIn(fade_duration);
-        {
+        public override void Hide() => this.FadeOut(fade_duration);
-            base.Update();
-
-            if (isCounting)
-            {
-                var currentTime = Clock.CurrentTime;
-                if (currentTime < endTime)
-                {
-                    int currentSecond = (int)Math.Ceiling((endTime - Clock.CurrentTime) / 1000.0);
-                    if (currentSecond != previousSecond)
-                    {
-                        counter.Text = currentSecond.ToString();
-                        previousSecond = currentSecond;
-                    }
-                }
-                else isCounting = false;
-            }
-        }
-
-        protected override void PopIn() => this.FadeIn(fade_duration);
-        protected override void PopOut() => this.FadeOut(fade_duration);
     }
 }