Merge pull request #3241 from smoogipoo/fix-mirror-note-conversion

Fix mirror note generation never completing
Merge branch 'master' into fix-mirror-note-conversion
2026-05-15 18:52:50 +08:00 · 2018-08-17 14:54:13 +09:00 · 2018-08-17 14:47:16 +09:00 · 2018-08-17 14:27:56 +09:00 · 2018-08-17 14:15:14 +09:00 · 2018-08-17 13:57:57 +09:00
126 changed files with 1517 additions and 901 deletions
@@ -4,7 +4,11 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 using osu.Framework;
+using osu.Framework.Development;
+using osu.Framework.Logging;
 using osu.Framework.Platform;
 using osu.Game.IPC;

@@ -20,6 +24,8 @@ namespace osu.Desktop

            using (DesktopGameHost host = Host.GetSuitableHost(@"osu", true))
            {
+                host.ExceptionThrown += handleException;
+
                if (!host.IsPrimaryInstance)
                {
                    var importer = new ArchiveImportIPCChannel(host);
@@ -45,5 +51,24 @@ namespace osu.Desktop
                return 0;
            }
        }
+
+        private static int allowableExceptions = DebugUtils.IsDebugBuild ? 0 : 1;
+
+        /// <summary>
+        /// Allow a maximum of one unhandled exception, per second of execution.
+        /// </summary>
+        /// <param name="arg"></param>
+        /// <returns></returns>
+        private static bool handleException(Exception arg)
+        {
+            bool continueExecution = Interlocked.Decrement(ref allowableExceptions) >= 0;
+
+            Logger.Log($"Unhandled exception has been {(continueExecution ? "allowed with {allowableExceptions} more allowable exceptions" : "denied")} .");
+
+            // restore the stock of allowable exceptions after a short delay.
+            Task.Delay(1000).ContinueWith(_ => Interlocked.Increment(ref allowableExceptions));
+
+            return continueExecution;
+        }
    }
 }
@@ -41,6 +41,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                    RepeatCount = curveData.RepeatCount,
                    X = (positionData?.X ?? 0) / CatchPlayfield.BASE_WIDTH,
                    NewCombo = comboData?.NewCombo ?? false,
+                    ComboOffset = comboData?.ComboOffset ?? 0,
                    LegacyLastTickOffset = legacyOffset?.LegacyLastTickOffset ?? 0
                };
            }
@@ -51,7 +52,8 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                    StartTime = obj.StartTime,
                    Samples = obj.Samples,
                    Duration = endTime.Duration,
-                    NewCombo = comboData?.NewCombo ?? false
+                    NewCombo = comboData?.NewCombo ?? false,
+                    ComboOffset = comboData?.ComboOffset ?? 0,
                };
            }
            else
@@ -61,6 +63,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                    StartTime = obj.StartTime,
                    Samples = obj.Samples,
                    NewCombo = comboData?.NewCombo ?? false,
+                    ComboOffset = comboData?.ComboOffset ?? 0,
                    X = (positionData?.X ?? 0) / CatchPlayfield.BASE_WIDTH
                };
            }
@@ -1,6 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;

 namespace osu.Game.Rulesets.Catch.Judgements
@@ -9,8 +10,6 @@ namespace osu.Game.Rulesets.Catch.Judgements
    {
        public override bool AffectsCombo => false;

-        public override bool ShouldExplode => true;
-
        protected override int NumericResultFor(HitResult result)
        {
            switch (result)
@@ -32,5 +31,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
                    return 8;
            }
        }
+
+        public override bool ShouldExplodeFor(JudgementResult result) => true;
    }
 }
@@ -23,21 +23,10 @@ namespace osu.Game.Rulesets.Catch.Judgements
        }

        /// <summary>
-        /// The base health increase for the result achieved.
+        /// Retrieves the numeric health increase of a <see cref="HitResult"/>.
        /// </summary>
-        public float HealthIncrease => HealthIncreaseFor(Result);
-
-        /// <summary>
-        /// Whether fruit on the platter should explode or drop.
-        /// Note that this is only checked if the owning object is also <see cref="IHasComboInformation.LastInCombo" />
-        /// </summary>
-        public virtual bool ShouldExplode => IsHit;
-
-        /// <summary>
-        /// Convert a <see cref="HitResult"/> to a base health increase.
-        /// </summary>
-        /// <param name="result">The value to convert.</param>
-        /// <returns>The base health increase.</returns>
+        /// <param name="result">The <see cref="HitResult"/> to find the numeric health increase for.</param>
+        /// <returns>The numeric health increase of <paramref name="result"/>.</returns>
        protected virtual float HealthIncreaseFor(HitResult result)
        {
            switch (result)
@@ -48,5 +37,18 @@ namespace osu.Game.Rulesets.Catch.Judgements
                    return 10.2f;
            }
        }
+
+        /// <summary>
+        /// Retrieves the numeric health increase of a <see cref="JudgementResult"/>.
+        /// </summary>
+        /// <param name="result">The <see cref="JudgementResult"/> to find the numeric health increase for.</param>
+        /// <returns>The numeric health increase of <paramref name="result"/>.</returns>
+        public float HealthIncreaseFor(JudgementResult result) => HealthIncreaseFor(result.Type);
+
+        /// <summary>
+        /// Whether fruit on the platter should explode or drop.
+        /// Note that this is only checked if the owning object is also <see cref="IHasComboInformation.LastInCombo" />
+        /// </summary>
+        public virtual bool ShouldExplodeFor(JudgementResult result) => result.IsHit;
    }
 }
@@ -1,10 +1,15 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Judgements;
+
 namespace osu.Game.Rulesets.Catch.Objects
 {
    public class Banana : Fruit
    {
        public override FruitVisualRepresentation VisualRepresentation => FruitVisualRepresentation.Banana;
+
+        public override Judgement CreateJudgement() => new CatchBananaJudgement();
    }
 }
@@ -20,6 +20,8 @@ namespace osu.Game.Rulesets.Catch.Objects

        public virtual bool NewCombo { get; set; }

+        public int ComboOffset { get; set; }
+
        public int IndexInCurrentCombo { get; set; }

        public int ComboIndex { get; set; }
@@ -1,8 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

-using osu.Game.Rulesets.Catch.Judgements;
-
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
    public class DrawableBanana : DrawableFruit
@@ -11,7 +9,5 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
            : base(h)
        {
        }
-
-        protected override CatchJudgement CreateJudgement() => new CatchBananaJudgement();
    }
 }
@@ -26,8 +26,6 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                AddNested(getVisualRepresentation?.Invoke(b));
        }

-        protected override bool ProvidesJudgement => false;
-
        protected override void AddNested(DrawableHitObject h)
        {
            ((DrawableCatchHitObject)h).CheckPosition = o => CheckPosition?.Invoke(o) ?? false;
@@ -5,7 +5,6 @@ using System;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Scoring;
@@ -53,20 +52,14 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable

        public Func<CatchHitObject, bool> CheckPosition;

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (CheckPosition == null) return;

-            if (timeOffset >= 0)
-            {
-                var judgement = CreateJudgement();
-                judgement.Result = CheckPosition.Invoke(HitObject) ? HitResult.Perfect : HitResult.Miss;
-                AddJudgement(judgement);
-            }
+            if (timeOffset >= 0 && Result != null)
+                ApplyResult(r => r.Type = CheckPosition.Invoke(HitObject) ? HitResult.Perfect : HitResult.Miss);
        }

-        protected virtual CatchJudgement CreateJudgement() => new CatchJudgement();
-
        protected override void SkinChanged(ISkinSource skin, bool allowFallback)
        {
            base.SkinChanged(skin, allowFallback);
@@ -6,7 +6,6 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
 using OpenTK;
 using OpenTK.Graphics;
-using osu.Game.Rulesets.Catch.Judgements;

 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
@@ -24,8 +23,6 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
            Masking = false;
        }

-        protected override CatchJudgement CreateJudgement() => new CatchDropletJudgement();
-
        [BackgroundDependencyLoader]
        private void load()
        {
@@ -26,8 +26,6 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawable
                AddNested(getVisualRepresentation?.Invoke(o));
        }

-        protected override bool ProvidesJudgement => false;
-
        protected override void AddNested(DrawableHitObject h)
        {
            var catchObject = (DrawableCatchHitObject)h;
@@ -2,18 +2,15 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

 using OpenTK;
-using osu.Game.Rulesets.Catch.Judgements;

 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {
    public class DrawableTinyDroplet : DrawableDroplet
    {
-        public DrawableTinyDroplet(Droplet h)
+        public DrawableTinyDroplet(TinyDroplet h)
            : base(h)
        {
            Size = new Vector2((float)CatchHitObject.OBJECT_RADIUS) / 8;
        }
-
-        protected override CatchJudgement CreateJudgement() => new CatchTinyDropletJudgement();
    }
 }
@@ -1,9 +1,13 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Judgements;
+
 namespace osu.Game.Rulesets.Catch.Objects
 {
    public class Droplet : CatchHitObject
    {
+        public override Judgement CreateJudgement() => new CatchDropletJudgement();
    }
 }
@@ -1,9 +1,13 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Judgements;
+
 namespace osu.Game.Rulesets.Catch.Objects
 {
    public class Fruit : CatchHitObject
    {
+        public override Judgement CreateJudgement() => new CatchJudgement();
    }
 }
@@ -1,9 +1,13 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using osu.Game.Rulesets.Catch.Judgements;
+using osu.Game.Rulesets.Judgements;
+
 namespace osu.Game.Rulesets.Catch.Objects
 {
    public class TinyDroplet : Droplet
    {
+        public override Judgement CreateJudgement() => new CatchTinyDropletJudgement();
    }
 }
@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

 using System;
-using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Judgements;
 using osu.Game.Rulesets.Catch.Objects;
@@ -21,55 +20,28 @@ namespace osu.Game.Rulesets.Catch.Scoring

        private float hpDrainRate;

-        protected override void SimulateAutoplay(Beatmap<CatchHitObject> beatmap)
+        protected override void ApplyBeatmap(Beatmap<CatchHitObject> beatmap)
        {
-            hpDrainRate = beatmap.BeatmapInfo.BaseDifficulty.DrainRate;
+            base.ApplyBeatmap(beatmap);

-            foreach (var obj in beatmap.HitObjects)
-            {
-                switch (obj)
-                {
-                    case JuiceStream stream:
-                        foreach (var nestedObject in stream.NestedHitObjects)
-                            switch (nestedObject)
-                            {
-                                case TinyDroplet _:
-                                    AddJudgement(new CatchTinyDropletJudgement { Result = HitResult.Perfect });
-                                    break;
-                                case Droplet _:
-                                    AddJudgement(new CatchDropletJudgement { Result = HitResult.Perfect });
-                                    break;
-                                case Fruit _:
-                                    AddJudgement(new CatchJudgement { Result = HitResult.Perfect });
-                                    break;
-                            }
-                        break;
-                    case BananaShower shower:
-                        foreach (var _ in shower.NestedHitObjects.Cast<CatchHitObject>())
-                            AddJudgement(new CatchBananaJudgement { Result = HitResult.Perfect });
-                        break;
-                    case Fruit _:
-                        AddJudgement(new CatchJudgement { Result = HitResult.Perfect });
-                        break;
-                }
-            }
+            hpDrainRate = beatmap.BeatmapInfo.BaseDifficulty.DrainRate;
        }

        private const double harshness = 0.01;

-        protected override void OnNewJudgement(Judgement judgement)
+        protected override void ApplyResult(JudgementResult result)
        {
-            base.OnNewJudgement(judgement);
+            base.ApplyResult(result);

-            if (judgement.Result == HitResult.Miss)
+            if (result.Type == HitResult.Miss)
            {
-                if (!judgement.IsBonus)
+                if (!result.Judgement.IsBonus)
                    Health.Value -= hpDrainRate * (harshness * 2);
                return;
            }

-            if (judgement is CatchJudgement catchJudgement)
-                Health.Value += Math.Max(catchJudgement.HealthIncrease - hpDrainRate, 0) * harshness;
+            if (result.Judgement is CatchJudgement catchJudgement)
+                Health.Value += Math.Max(catchJudgement.HealthIncreaseFor(result) - hpDrainRate, 0) * harshness;
        }
    }
 }
@@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Catch.UI

        public override void Add(DrawableHitObject h)
        {
-            h.OnJudgement += onJudgement;
+            h.OnNewResult += onNewResult;

            base.Add(h);

@@ -67,6 +67,7 @@ namespace osu.Game.Rulesets.Catch.UI
            fruit.CheckPosition = CheckIfWeCanCatch;
        }

-        private void onJudgement(DrawableHitObject judgedObject, Judgement judgement) => catcherArea.OnJudgement((DrawableCatchHitObject)judgedObject, judgement);
+        private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
+            => catcherArea.OnResult((DrawableCatchHitObject)judgedObject, result);
    }
 }
@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Catch.UI

        private DrawableCatchHitObject lastPlateableFruit;

-        public void OnJudgement(DrawableCatchHitObject fruit, Judgement judgement)
+        public void OnResult(DrawableCatchHitObject fruit, JudgementResult result)
        {
            void runAfterLoaded(Action action)
            {
@@ -63,7 +63,7 @@ namespace osu.Game.Rulesets.Catch.UI
                    lastPlateableFruit.OnLoadComplete = _ => action();
            }

-            if (judgement.IsHit && fruit.CanBePlated)
+            if (result.IsHit && fruit.CanBePlated)
            {
                var caughtFruit = (DrawableCatchHitObject)GetVisualRepresentation?.Invoke(fruit.HitObject);

@@ -86,7 +86,7 @@ namespace osu.Game.Rulesets.Catch.UI

            if (fruit.HitObject.LastInCombo)
            {
-                if (((CatchJudgement)judgement).ShouldExplode)
+                if (((CatchJudgement)result.Judgement).ShouldExplodeFor(result))
                    runAfterLoaded(() => MovableCatcher.Explode());
                else
                    MovableCatcher.Drop();
@@ -176,16 +176,23 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
            int nextColumn = Random.Next(RandomStart, TotalColumns);
            for (int i = 0; i < Math.Min(usableColumns, noteCount); i++)
            {
-                while (pattern.ColumnHasObject(nextColumn) || PreviousPattern.ColumnHasObject(nextColumn))  //find available column
+                // Find available column
+                RunWhile(() => pattern.ColumnHasObject(nextColumn) || PreviousPattern.ColumnHasObject(nextColumn), () =>
+                {
                    nextColumn = Random.Next(RandomStart, TotalColumns);
+                });
+
                addToPattern(pattern, nextColumn, startTime, EndTime);
            }

            // This is can't be combined with the above loop due to RNG
            for (int i = 0; i < noteCount - usableColumns; i++)
            {
-                while (pattern.ColumnHasObject(nextColumn))
+                RunWhile(() => pattern.ColumnHasObject(nextColumn), () =>
+                {
                    nextColumn = Random.Next(RandomStart, TotalColumns);
+                });
+
                addToPattern(pattern, nextColumn, startTime, EndTime);
            }

@@ -211,16 +218,21 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
            int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
            if (convertType.HasFlag(PatternType.ForceNotStack) && PreviousPattern.ColumnWithObjects < TotalColumns)
            {
-                while (PreviousPattern.ColumnHasObject(nextColumn))
+                RunWhile(() => PreviousPattern.ColumnHasObject(nextColumn), () =>
+                {
                    nextColumn = Random.Next(RandomStart, TotalColumns);
+                });
            }

            int lastColumn = nextColumn;
            for (int i = 0; i < noteCount; i++)
            {
                addToPattern(pattern, nextColumn, startTime, startTime);
-                while (nextColumn == lastColumn)
+
+                RunWhile(() => nextColumn == lastColumn, () =>
+                {
                    nextColumn = Random.Next(RandomStart, TotalColumns);
+                });

                lastColumn = nextColumn;
                startTime += SegmentDuration;
@@ -393,14 +405,18 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
            int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
            if (convertType.HasFlag(PatternType.ForceNotStack) && PreviousPattern.ColumnWithObjects < TotalColumns)
            {
-                while (PreviousPattern.ColumnHasObject(nextColumn))
+                RunWhile(() => PreviousPattern.ColumnHasObject(nextColumn), () =>
+                {
                    nextColumn = Random.Next(RandomStart, TotalColumns);
+                });
            }

            for (int i = 0; i < columnRepeat; i++)
            {
-                while (pattern.ColumnHasObject(nextColumn))
+                RunWhile(() => pattern.ColumnHasObject(nextColumn), () =>
+                {
                    nextColumn = Random.Next(RandomStart, TotalColumns);
+                });

                addToPattern(pattern, nextColumn, startTime, EndTime);
                startTime += SegmentDuration;
@@ -427,8 +443,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
            int holdColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
            if (convertType.HasFlag(PatternType.ForceNotStack) && PreviousPattern.ColumnWithObjects < TotalColumns)
            {
-                while (PreviousPattern.ColumnHasObject(holdColumn))
+                RunWhile(() => PreviousPattern.ColumnHasObject(holdColumn), () =>
+                {
                    holdColumn = Random.Next(RandomStart, TotalColumns);
+                });
            }

            // Create the hold note
@@ -455,8 +473,11 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                {
                    for (int j = 0; j < noteCount; j++)
                    {
-                        while (rowPattern.ColumnHasObject(nextColumn) || nextColumn == holdColumn)
+                        RunWhile(() => rowPattern.ColumnHasObject(nextColumn) || nextColumn == holdColumn, () =>
+                        {
                            nextColumn = Random.Next(RandomStart, TotalColumns);
+                        });
+
                        addToPattern(rowPattern, nextColumn, startTime, startTime);
                    }
                }
@@ -59,8 +59,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
        {
            int nextColumn = Random.Next(start, TotalColumns);

-            while (PreviousPattern.ColumnHasObject(nextColumn))
+            RunWhile(() => PreviousPattern.ColumnHasObject(nextColumn), () =>
+            {
                nextColumn = Random.Next(start, TotalColumns);
+            });

            return nextColumn;
        }
@@ -234,7 +234,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
            int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
            for (int i = 0; i < noteCount; i++)
            {
-                while (pattern.ColumnHasObject(nextColumn) || PreviousPattern.ColumnHasObject(nextColumn) && !allowStacking)
+                RunWhile(() => pattern.ColumnHasObject(nextColumn) || PreviousPattern.ColumnHasObject(nextColumn) && !allowStacking, () =>
                {
                    if (convertType.HasFlag(PatternType.Gathered))
                    {
@@ -244,7 +244,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                    }
                    else
                        nextColumn = Random.Next(RandomStart, TotalColumns);
-                }
+                });

                addToPattern(pattern, nextColumn);
            }
@@ -286,6 +286,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
        /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
        private Pattern generateRandomPatternWithMirrored(double centreProbability, double p2, double p3)
        {
+            if (convertType.HasFlag(PatternType.ForceNotStack))
+                return generateRandomPattern(1 / 2f + p2 / 2, p2, (p2 + p3) / 2, p3);
+
            var pattern = new Pattern();

            bool addToCentre;
@@ -295,8 +298,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
            int nextColumn = Random.Next(RandomStart, columnLimit);
            for (int i = 0; i < noteCount; i++)
            {
-                while (pattern.ColumnHasObject(nextColumn))
+                RunWhile(() => pattern.ColumnHasObject(nextColumn), () =>
+                {
                    nextColumn = Random.Next(RandomStart, columnLimit);
+                });

                // Add normal note
                addToPattern(pattern, nextColumn);
@@ -368,9 +373,6 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
        {
            addToCentre = false;

-            if (convertType.HasFlag(PatternType.ForceNotStack))
-                return getRandomNoteCount(1 / 2f + p2 / 2, p2, (p2 + p3) / 2, p3);
-
            switch (TotalColumns)
            {
                case 2:
@@ -3,6 +3,9 @@

 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using JetBrains.Annotations;
+using osu.Framework.Logging;
 using osu.Game.Rulesets.Objects;

 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
@@ -12,6 +15,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
    /// </summary>
    internal abstract class PatternGenerator
    {
+        /// <summary>
+        /// An arbitrary maximum amount of iterations to perform in <see cref="RunWhile"/>.
+        /// The specific value is not super important - enough such that no false-positives occur.
+        ///
+        /// /b/933228 requires at least 23 iterations.
+        /// </summary>
+        private const int max_rng_iterations = 30;
+
        /// <summary>
        /// The last pattern.
        /// </summary>
@@ -42,10 +53,44 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
            TotalColumns = Beatmap.TotalColumns;
        }

+        protected void RunWhile([InstantHandle] Func<bool> condition, Action action)
+        {
+            int iterations = 0;
+
+            while (condition())
+            {
+                if (iterations++ >= max_rng_iterations)
+                {
+                    // log an error but don't throw. we want to continue execution.
+                    Logger.Error(new ExceededAllowedIterationsException(new StackTrace(0)),
+                        "Conversion encountered errors. The beatmap may not be correctly converted.");
+                    return;
+                }
+
+                action();
+            }
+        }
+
        /// <summary>
        /// Generates the patterns for <see cref="HitObject"/>, each filled with hit objects.
        /// </summary>
        /// <returns>The <see cref="Pattern"/>s containing the hit objects.</returns>
        public abstract IEnumerable<Pattern> Generate();
+
+        /// <summary>
+        /// Denotes when a single conversion operation is in an infinitely looping state.
+        /// </summary>
+        public class ExceededAllowedIterationsException : Exception
+        {
+            private readonly string stackTrace;
+
+            public ExceededAllowedIterationsException(StackTrace stackTrace)
+            {
+                this.stackTrace = stackTrace.ToString();
+            }
+
+            public override string StackTrace => stackTrace;
+            public override string ToString() => $"{GetType().Name}: {Message}\r\n{StackTrace}";
+        }
    }
 }
@@ -1,27 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Game.Rulesets.Scoring;
-
-namespace osu.Game.Rulesets.Mania.Judgements
-{
-    public class HoldNoteTailJudgement : ManiaJudgement
-    {
-        /// <summary>
-        /// Whether the hold note has been released too early and shouldn't give full score for the release.
-        /// </summary>
-        public bool HasBroken;
-
-        protected override int NumericResultFor(HitResult result)
-        {
-            switch (result)
-            {
-                default:
-                    return base.NumericResultFor(result);
-                case HitResult.Great:
-                case HitResult.Perfect:
-                    return base.NumericResultFor(HasBroken ? HitResult.Good : result);
-            }
-        }
-    }
-}
@@ -7,7 +7,6 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using OpenTK.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Mania.Judgements;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI.Scrolling;
@@ -19,7 +18,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
    /// </summary>
    public class DrawableHoldNote : DrawableManiaHitObject<HoldNote>, IKeyBindingHandler<ManiaAction>
    {
-        public override bool DisplayJudgement => false;
+        public override bool DisplayResult => false;

        public readonly DrawableNote Head;
        public readonly DrawableNote Tail;
@@ -97,10 +96,10 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
            }
        }

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (Tail.AllJudged)
-                AddJudgement(new HoldNoteJudgement { Result = HitResult.Perfect });
+                ApplyResult(r => r.Type = HitResult.Perfect);
        }

        protected override void Update()
@@ -166,7 +165,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                    return false;

                // If the key has been released too early, the user should not receive full score for the release
-                if (Judgements.Any(j => j.Result == HitResult.Miss))
+                if (Result.Type == HitResult.Miss)
                    holdNote.hasBroken = true;

                // The head note also handles early hits before the body, but we want accurate early hits to count as the body being held
@@ -197,7 +196,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                this.holdNote = holdNote;
            }

-            protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+            protected override void CheckForResult(bool userTriggered, double timeOffset)
            {
                // Factor in the release lenience
                timeOffset /= release_window_lenience;
@@ -205,13 +204,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                if (!userTriggered)
                {
                    if (!HitObject.HitWindows.CanBeHit(timeOffset))
-                    {
-                        AddJudgement(new HoldNoteTailJudgement
-                        {
-                            Result = HitResult.Miss,
-                            HasBroken = holdNote.hasBroken
-                        });
-                    }
+                        ApplyResult(r => r.Type = HitResult.Miss);

                    return;
                }
@@ -220,10 +213,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                if (result == HitResult.None)
                    return;

-                AddJudgement(new HoldNoteTailJudgement
+                ApplyResult(r =>
                {
-                    Result = result,
-                    HasBroken = holdNote.hasBroken
+                    if (holdNote.hasBroken && (result == HitResult.Perfect || result == HitResult.Perfect))
+                        result = HitResult.Good;
+
+                    r.Type = result;
                });
            }

@@ -238,7 +233,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
                if (action != Action.Value)
                    return false;

-                UpdateJudgement(true);
+                UpdateResult(true);

                // Handled by the hold note, which will set holding = false
                return false;
@@ -7,7 +7,6 @@ using OpenTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Mania.Judgements;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Scoring;

@@ -72,29 +71,17 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
            }
        }

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
-            if (!userTriggered)
-                return;
-
            if (Time.Current < HitObject.StartTime)
                return;

-            if (HoldStartTime?.Invoke() > HitObject.StartTime)
-                return;
+            var startTime = HoldStartTime?.Invoke();

-            AddJudgement(new HoldNoteTickJudgement { Result = HitResult.Perfect });
-        }
-
-        protected override void Update()
-        {
-            if (AllJudged)
-                return;
-
-            if (HoldStartTime?.Invoke() == null)
-                return;
-
-            UpdateJudgement(true);
+            if (startTime == null || startTime > HitObject.StartTime)
+                ApplyResult(r => r.Type = HitResult.Miss);
+            else
+                ApplyResult(r => r.Type = HitResult.Perfect);
        }
    }
 }
@@ -6,7 +6,6 @@ using OpenTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
-using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI.Scrolling;
@@ -56,12 +55,12 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
            }
        }

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (!userTriggered)
            {
                if (!HitObject.HitWindows.CanBeHit(timeOffset))
-                    AddJudgement(new ManiaJudgement { Result = HitResult.Miss });
+                    ApplyResult(r => r.Type = HitResult.Miss);
                return;
            }

@@ -69,7 +68,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
            if (result == HitResult.None)
                return;

-            AddJudgement(new ManiaJudgement { Result = result });
+            ApplyResult(r => r.Type = result);
        }

        public virtual bool OnPressed(ManiaAction action)
@@ -77,7 +76,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
            if (action != Action.Value)
                return false;

-            return UpdateJudgement(true);
+            return UpdateResult(true);
        }

        public virtual bool OnReleased(ManiaAction action) => false;
@@ -3,6 +3,8 @@

 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.Judgements;
 using osu.Game.Rulesets.Objects.Types;

 namespace osu.Game.Rulesets.Mania.Objects
@@ -55,7 +57,7 @@ namespace osu.Game.Rulesets.Mania.Objects
        /// <summary>
        /// The tail note of the hold.
        /// </summary>
-        public readonly Note Tail = new Note();
+        public readonly TailNote Tail = new TailNote();

        /// <summary>
        /// The time between ticks of this hold.
@@ -68,9 +70,6 @@ namespace osu.Game.Rulesets.Mania.Objects

            TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
            tickSpacing = timingPoint.BeatLength / difficulty.SliderTickRate;
-
-            Head.ApplyDefaults(controlPointInfo, difficulty);
-            Tail.ApplyDefaults(controlPointInfo, difficulty);
        }

        protected override void CreateNestedHitObjects()
@@ -78,6 +77,9 @@ namespace osu.Game.Rulesets.Mania.Objects
            base.CreateNestedHitObjects();

            createTicks();
+
+            AddNested(Head);
+            AddNested(Tail);
        }

        private void createTicks()
@@ -94,5 +96,7 @@ namespace osu.Game.Rulesets.Mania.Objects
                });
            }
        }
+
+        public override Judgement CreateJudgement() => new HoldNoteJudgement();
    }
 }
@@ -1,6 +1,9 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.Judgements;
+
 namespace osu.Game.Rulesets.Mania.Objects
 {
    /// <summary>
@@ -8,5 +11,6 @@ namespace osu.Game.Rulesets.Mania.Objects
    /// </summary>
    public class HoldNoteTick : ManiaHitObject
    {
+        public override Judgement CreateJudgement() => new HoldNoteTickJudgement();
    }
 }
@@ -1,6 +1,9 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.Judgements;
+
 namespace osu.Game.Rulesets.Mania.Objects
 {
    /// <summary>
@@ -8,5 +11,6 @@ namespace osu.Game.Rulesets.Mania.Objects
    /// </summary>
    public class Note : ManiaHitObject
    {
+        public override Judgement CreateJudgement() => new ManiaJudgement();
    }
 }
@@ -0,0 +1,13 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Mania.Judgements;
+
+namespace osu.Game.Rulesets.Mania.Objects
+{
+    public class TailNote : Note
+    {
+        public override Judgement CreateJudgement() => new ManiaJudgement();
+    }
+}
@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

-using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Mania.Judgements;
@@ -97,31 +96,20 @@ namespace osu.Game.Rulesets.Mania.Scoring
        {
        }

-        protected override void SimulateAutoplay(Beatmap<ManiaHitObject> beatmap)
+        protected override void ApplyBeatmap(Beatmap<ManiaHitObject> beatmap)
        {
+            base.ApplyBeatmap(beatmap);
+
            BeatmapDifficulty difficulty = beatmap.BeatmapInfo.BaseDifficulty;
            hpMultiplier = BeatmapDifficulty.DifficultyRange(difficulty.DrainRate, hp_multiplier_min, hp_multiplier_mid, hp_multiplier_max);
            hpMissMultiplier = BeatmapDifficulty.DifficultyRange(difficulty.DrainRate, hp_multiplier_miss_min, hp_multiplier_miss_mid, hp_multiplier_miss_max);
+        }

+        protected override void SimulateAutoplay(Beatmap<ManiaHitObject> beatmap)
+        {
            while (true)
            {
-                foreach (var obj in beatmap.HitObjects)
-                {
-                    var holdNote = obj as HoldNote;
-
-                    if (holdNote != null)
-                    {
-                        // Head
-                        AddJudgement(new ManiaJudgement { Result = HitResult.Perfect });
-
-                        // Ticks
-                        int tickCount = holdNote.NestedHitObjects.OfType<HoldNoteTick>().Count();
-                        for (int i = 0; i < tickCount; i++)
-                            AddJudgement(new HoldNoteTickJudgement { Result = HitResult.Perfect });
-                    }
-
-                    AddJudgement(new ManiaJudgement { Result = HitResult.Perfect });
-                }
+                base.SimulateAutoplay(beatmap);

                if (!HasFailed)
                    break;
@@ -133,20 +121,20 @@ namespace osu.Game.Rulesets.Mania.Scoring
            }
        }

-        protected override void OnNewJudgement(Judgement judgement)
+        protected override void ApplyResult(JudgementResult result)
        {
-            base.OnNewJudgement(judgement);
+            base.ApplyResult(result);

-            bool isTick = judgement is HoldNoteTickJudgement;
+            bool isTick = result.Judgement is HoldNoteTickJudgement;

            if (isTick)
            {
-                if (judgement.IsHit)
+                if (result.IsHit)
                    Health.Value += hpMultiplier * hp_increase_tick;
            }
            else
            {
-                switch (judgement.Result)
+                switch (result.Type)
                {
                    case HitResult.Miss:
                        Health.Value += hpMissMultiplier * hp_increase_miss;
@@ -131,14 +131,14 @@ namespace osu.Game.Rulesets.Mania.UI
        public override void Add(DrawableHitObject hitObject)
        {
            hitObject.AccentColour = AccentColour;
-            hitObject.OnJudgement += OnJudgement;
+            hitObject.OnNewResult += OnNewResult;

            HitObjects.Add(hitObject);
        }

-        internal void OnJudgement(DrawableHitObject judgedObject, Judgement judgement)
+        internal void OnNewResult(DrawableHitObject judgedObject, JudgementResult result)
        {
-            if (!judgement.IsHit || !judgedObject.DisplayJudgement || !DisplayJudgements)
+            if (!result.IsHit || !judgedObject.DisplayResult || !DisplayJudgements)
                return;

            explosionContainer.Add(new HitExplosion(judgedObject)
@@ -10,8 +10,8 @@ namespace osu.Game.Rulesets.Mania.UI
 {
    public class DrawableManiaJudgement : DrawableJudgement
    {
-        public DrawableManiaJudgement(Judgement judgement, DrawableHitObject judgedObject)
-            : base(judgement, judgedObject)
+        public DrawableManiaJudgement(JudgementResult result, DrawableHitObject judgedObject)
+            : base(result, judgedObject)
        {
        }

@@ -28,7 +28,7 @@ namespace osu.Game.Rulesets.Mania.UI

            this.FadeInFromZero(50, Easing.OutQuint);

-            if (Judgement.IsHit)
+            if (Result.IsHit)
            {
                this.ScaleTo(0.8f);
                this.ScaleTo(1, 250, Easing.OutElastic);
@@ -156,18 +156,18 @@ namespace osu.Game.Rulesets.Mania.UI
            var maniaObject = (ManiaHitObject)h.HitObject;
            int columnIndex = maniaObject.Column - firstColumnIndex;
            Columns.ElementAt(columnIndex).Add(h);
-            h.OnJudgement += OnJudgement;
+            h.OnNewResult += OnNewResult;
        }

        public void Add(BarLine barline) => base.Add(new DrawableBarLine(barline));

-        internal void OnJudgement(DrawableHitObject judgedObject, Judgement judgement)
+        internal void OnNewResult(DrawableHitObject judgedObject, JudgementResult result)
        {
-            if (!judgedObject.DisplayJudgement || !DisplayJudgements)
+            if (!judgedObject.DisplayResult || !DisplayJudgements)
                return;

            judgements.Clear();
-            judgements.Add(new DrawableManiaJudgement(judgement, judgedObject)
+            judgements.Add(new DrawableManiaJudgement(result, judgedObject)
            {
                Anchor = Anchor.Centre,
                Origin = Anchor.Centre,
@@ -5,12 +5,10 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
-using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 using OpenTK;
-using osu.Game.Rulesets.Osu.Judgements;
 using System.Collections.Generic;
 using System;
 using osu.Game.Rulesets.Mods;
@@ -96,19 +94,15 @@ namespace osu.Game.Rulesets.Osu.Tests
                this.auto = auto;
            }

-            protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+            protected override void CheckForResult(bool userTriggered, double timeOffset)
            {
                if (auto && !userTriggered && timeOffset > 0)
                {
                    // force success
-                    AddJudgement(new OsuJudgement
-                    {
-                        Result = HitResult.Great
-                    });
-                    State.Value = ArmedState.Hit;
+                    ApplyResult(r => r.Type = HitResult.Great);
                }
                else
-                    base.CheckForJudgements(userTriggered, timeOffset);
+                    base.CheckForResult(userTriggered, timeOffset);
            }
        }
    }
@@ -304,13 +304,13 @@ namespace osu.Game.Rulesets.Osu.Tests
            foreach (var mod in Mods.OfType<IApplicableToDrawableHitObjects>())
                mod.ApplyToDrawableHitObjects(new[] { drawable });

-            drawable.OnJudgement += onJudgement;
+            drawable.OnNewResult += onNewResult;

            Add(drawable);
        }

        private float judgementOffsetDirection = 1;
-        private void onJudgement(DrawableHitObject judgedObject, Judgement judgement)
+        private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
        {
            var osuObject = judgedObject as DrawableOsuHitObject;
            if (osuObject == null)
@@ -321,8 +321,8 @@ namespace osu.Game.Rulesets.Osu.Tests
            {
                Anchor = Anchor.Centre,
                Origin = Anchor.Centre,
-                Text = judgement.IsHit ? "Hit!" : "Miss!",
-                Colour = judgement.IsHit ? Color4.Green : Color4.Red,
+                Text = result.IsHit ? "Hit!" : "Miss!",
+                Colour = result.IsHit ? Color4.Green : Color4.Red,
                TextSize = 30,
                Position = osuObject.HitObject.StackedEndPosition + judgementOffsetDirection * new Vector2(0, 45)
            });
@@ -72,7 +72,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                this.auto = auto;
            }

-            protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+            protected override void CheckForResult(bool userTriggered, double timeOffset)
            {
                if (auto && !userTriggered && Time.Current > Spinner.StartTime + Spinner.Duration / 2 && Progress < 1)
                {
@@ -81,7 +81,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                    auto = false;
                }

-                base.CheckForJudgements(userTriggered, timeOffset);
+                base.CheckForResult(userTriggered, timeOffset);
            }
        }
    }
@@ -12,7 +12,7 @@ using osu.Game.Rulesets.Osu.UI;

 namespace osu.Game.Rulesets.Osu.Beatmaps
 {
-    internal class OsuBeatmapConverter : BeatmapConverter<OsuHitObject>
+    public class OsuBeatmapConverter : BeatmapConverter<OsuHitObject>
    {
        public OsuBeatmapConverter(IBeatmap beatmap)
            : base(beatmap)
@@ -42,6 +42,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                    RepeatCount = curveData.RepeatCount,
                    Position = positionData?.Position ?? Vector2.Zero,
                    NewCombo = comboData?.NewCombo ?? false,
+                    ComboOffset = comboData?.ComboOffset ?? 0,
                    LegacyLastTickOffset = legacyOffset?.LegacyLastTickOffset
                };
            }
@@ -52,7 +53,9 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                    StartTime = original.StartTime,
                    Samples = original.Samples,
                    EndTime = endTimeData.EndTime,
-                    Position = positionData?.Position ?? OsuPlayfield.BASE_SIZE / 2
+                    Position = positionData?.Position ?? OsuPlayfield.BASE_SIZE / 2,
+                    NewCombo = comboData?.NewCombo ?? false,
+                    ComboOffset = comboData?.ComboOffset ?? 0,
                };
            }
            else
@@ -62,7 +65,8 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                    StartTime = original.StartTime,
                    Samples = original.Samples,
                    Position = positionData?.Position ?? Vector2.Zero,
-                    NewCombo = comboData?.NewCombo ?? false
+                    NewCombo = comboData?.NewCombo ?? false,
+                    ComboOffset = comboData?.ComboOffset ?? 0,
                };
            }
        }
@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Osu.Objects;

 namespace osu.Game.Rulesets.Osu.Beatmaps
 {
-    internal class OsuBeatmapProcessor : BeatmapProcessor
+    public class OsuBeatmapProcessor : BeatmapProcessor
    {
        public OsuBeatmapProcessor(IBeatmap beatmap)
            : base(beatmap)
@@ -0,0 +1,17 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.ComponentModel;
+
+namespace osu.Game.Rulesets.Osu.Judgements
+{
+    public enum ComboResult
+    {
+        [Description(@"")]
+        None,
+        [Description(@"Good")]
+        Good,
+        [Description(@"Amazing")]
+        Perfect
+    }
+}
@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

 using osu.Game.Rulesets.Judgements;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;

 namespace osu.Game.Rulesets.Osu.Judgements
@@ -25,7 +24,5 @@ namespace osu.Game.Rulesets.Osu.Judgements
                    return 300;
            }
        }
-
-        public ComboResult Combo;
    }
 }
@@ -0,0 +1,17 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Judgements;
+
+namespace osu.Game.Rulesets.Osu.Judgements
+{
+    public class OsuJudgementResult : JudgementResult
+    {
+        public ComboResult ComboType;
+
+        public OsuJudgementResult(Judgement judgement)
+            : base(judgement)
+        {
+        }
+    }
+}
@@ -6,7 +6,6 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
 using OpenTK;
-using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 using OpenTK.Graphics;

@@ -40,7 +39,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                        if (AllJudged)
                            return false;

-                        UpdateJudgement(true);
+                        UpdateResult(true);
                        return true;
                    },
                },
@@ -77,12 +76,13 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            }
        }

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (!userTriggered)
            {
                if (!HitObject.HitWindows.CanBeHit(timeOffset))
-                    AddJudgement(new OsuJudgement { Result = HitResult.Miss });
+                    ApplyResult(r => r.Type = HitResult.Miss);
+
                return;
            }

@@ -90,10 +90,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            if (result == HitResult.None)
                return;

-            AddJudgement(new OsuJudgement
-            {
-                Result = result,
-            });
+            ApplyResult(r => r.Type = result);
        }

        protected override void UpdatePreemptState()
@@ -2,11 +2,11 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

 using System;
-using System.ComponentModel;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Framework.Graphics;
-using System.Linq;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using OpenTK.Graphics;
@@ -34,7 +34,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            {
                UpdatePreemptState();

-                var judgementOffset = Math.Min(HitObject.HitWindows.HalfWindowFor(HitResult.Miss), Judgements.FirstOrDefault()?.TimeOffset ?? 0);
+                var judgementOffset = Math.Min(HitObject.HitWindows.HalfWindowFor(HitResult.Miss), Result?.TimeOffset ?? 0);

                using (BeginDelayedSequence(HitObject.TimePreempt + judgementOffset, true))
                    UpdateCurrentState(state);
@@ -57,20 +57,17 @@ 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) { }
+        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);
-    }

-    public enum ComboResult
-    {
-        [Description(@"")]
-        None,
-        [Description(@"Good")]
-        Good,
-        [Description(@"Amazing")]
-        Perfect
+        protected override JudgementResult CreateResult(Judgement judgement) => new OsuJudgementResult(judgement);
    }
 }
@@ -11,14 +11,14 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
    public class DrawableOsuJudgement : DrawableJudgement
    {
-        public DrawableOsuJudgement(Judgement judgement, DrawableHitObject judgedObject)
-            : base(judgement, judgedObject)
+        public DrawableOsuJudgement(JudgementResult result, DrawableHitObject judgedObject)
+            : base(result, judgedObject)
        {
        }

        protected override void LoadComplete()
        {
-            if (Judgement.Result != HitResult.Miss)
+            if (Result.Type != HitResult.Miss)
                JudgementText?.TransformSpacingTo(new Vector2(14, 0), 1800, Easing.OutQuint);

            base.LoadComplete();
@@ -8,7 +8,6 @@ using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Objects.Drawables;
 using OpenTK;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;

@@ -42,10 +41,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            };
        }

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (repeatPoint.StartTime <= Time.Current)
-                AddJudgement(new OsuJudgement { Result = drawableSlider.Tracking ? HitResult.Great : HitResult.Miss });
+                ApplyResult(r => r.Type = drawableSlider.Tracking ? HitResult.Great : HitResult.Miss);
        }

        protected override void UpdatePreemptState()
@@ -9,7 +9,6 @@ using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Scoring;
 using OpenTK.Graphics;
@@ -132,23 +131,27 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            }
        }

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
-            if (!userTriggered && Time.Current >= slider.EndTime)
+            if (userTriggered || Time.Current < slider.EndTime)
+                return;
+
+            ApplyResult(r =>
            {
                var judgementsCount = NestedHitObjects.Count();
                var judgementsHit = NestedHitObjects.Count(h => h.IsHit);

                var hitFraction = (double)judgementsHit / judgementsCount;
-                if (hitFraction == 1 && HeadCircle.Judgements.Any(j => j.Result == HitResult.Great))
-                    AddJudgement(new OsuJudgement { Result = HitResult.Great });
-                else if (hitFraction >= 0.5 && HeadCircle.Judgements.Any(j => j.Result >= HitResult.Good))
-                    AddJudgement(new OsuJudgement { Result = HitResult.Good });
+
+                if (hitFraction == 1 && HeadCircle.Result.Type == HitResult.Great)
+                    r.Type = HitResult.Great;
+                else if (hitFraction >= 0.5 && HeadCircle.Result.Type >= HitResult.Good)
+                    r.Type = HitResult.Good;
                else if (hitFraction > 0)
-                    AddJudgement(new OsuJudgement { Result = HitResult.Meh });
+                    r.Type = HitResult.Meh;
                else
-                    AddJudgement(new OsuJudgement { Result = HitResult.Miss });
-            }
+                    r.Type = HitResult.Miss;
+            });
        }

        protected override void UpdateCurrentState(ArmedState state)
@@ -2,7 +2,6 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;

 namespace osu.Game.Rulesets.Osu.Objects.Drawables
@@ -12,11 +11,11 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
        /// <summary>
        /// The judgement text is provided by the <see cref="DrawableSlider"/>.
        /// </summary>
-        public override bool DisplayJudgement => false;
+        public override bool DisplayResult => false;

        public bool Tracking { get; set; }

-        public DrawableSliderTail(Slider slider, HitCircle hitCircle)
+        public DrawableSliderTail(Slider slider, SliderTailCircle hitCircle)
            : base(hitCircle)
        {
            Origin = Anchor.Centre;
@@ -29,10 +28,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            Position = HitObject.Position - slider.Position;
        }

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (!userTriggered && timeOffset >= 0)
-                AddJudgement(new OsuSliderTailJudgement { Result = Tracking ? HitResult.Great : HitResult.Miss });
+                ApplyResult(r => r.Type = Tracking ? HitResult.Great : HitResult.Miss);
        }
    }
 }
@@ -6,7 +6,6 @@ using osu.Game.Rulesets.Objects.Drawables;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using osu.Framework.Graphics.Containers;
@@ -19,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

        public bool Tracking { get; set; }

-        public override bool DisplayJudgement => false;
+        public override bool DisplayResult => false;

        public DrawableSliderTick(SliderTick sliderTick) : base(sliderTick)
        {
@@ -48,10 +47,10 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
            };
        }

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (timeOffset >= 0)
-                AddJudgement(new OsuJudgement { Result = Tracking ? HitResult.Great : HitResult.Miss });
+                ApplyResult(r => r.Type = Tracking ? HitResult.Great : HitResult.Miss);
        }

        protected override void UpdatePreemptState()
@@ -11,7 +11,6 @@ using OpenTK.Graphics;
 using osu.Game.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Allocation;
-using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Screens.Ranking;
 using osu.Game.Rulesets.Scoring;

@@ -117,7 +116,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables

        public float Progress => MathHelper.Clamp(Disc.RotationAbsolute / 360 / Spinner.SpinsRequired, 0, 1);

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (Time.Current < HitObject.StartTime) return;

@@ -136,17 +135,20 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                glow.FadeColour(completeColour, duration);
            }

-            if (!userTriggered && Time.Current >= Spinner.EndTime)
+            if (userTriggered || Time.Current < Spinner.EndTime)
+                return;
+
+            ApplyResult(r =>
            {
                if (Progress >= 1)
-                    AddJudgement(new OsuJudgement { Result = HitResult.Great });
+                    r.Type = HitResult.Great;
                else if (Progress > .9)
-                    AddJudgement(new OsuJudgement { Result = HitResult.Good });
+                    r.Type = HitResult.Good;
                else if (Progress > .75)
-                    AddJudgement(new OsuJudgement { Result = HitResult.Meh });
+                    r.Type = HitResult.Meh;
                else if (Time.Current >= Spinner.EndTime)
-                    AddJudgement(new OsuJudgement { Result = HitResult.Miss });
-            }
+                    r.Type = HitResult.Miss;
+            });
        }

        [BackgroundDependencyLoader]
@@ -1,9 +1,13 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu.Judgements;
+
 namespace osu.Game.Rulesets.Osu.Objects
 {
    public class HitCircle : OsuHitObject
    {
+        public override Judgement CreateJudgement() => new OsuJudgement();
    }
 }
@@ -54,6 +54,8 @@ namespace osu.Game.Rulesets.Osu.Objects

        public virtual bool NewCombo { get; set; }

+        public int ComboOffset { get; set; }
+
        public virtual int IndexInCurrentCombo { get; set; }

        public virtual int ComboIndex { get; set; }
@@ -4,6 +4,8 @@
 using System;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu.Judgements;

 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -24,5 +26,7 @@ namespace osu.Game.Rulesets.Osu.Objects
            if (RepeatIndex > 0)
                TimePreempt = Math.Min(SpanDuration * 2, TimePreempt);
        }
+
+        public override Judgement CreateJudgement() => new OsuJudgement();
    }
 }
@@ -10,6 +10,8 @@ using System.Linq;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu.Judgements;

 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -94,7 +96,7 @@ namespace osu.Game.Rulesets.Osu.Objects
        public double TickDistance;

        public HitCircle HeadCircle;
-        public HitCircle TailCircle;
+        public SliderTailCircle TailCircle;

        protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
        {
@@ -133,7 +135,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                ComboIndex = ComboIndex,
            };

-            TailCircle = new SliderCircle(this)
+            TailCircle = new SliderTailCircle(this)
            {
                StartTime = EndTime,
                Position = EndPosition,
@@ -211,5 +213,7 @@ namespace osu.Game.Rulesets.Osu.Objects
                });
            }
        }
+
+        public override Judgement CreateJudgement() => new OsuJudgement();
    }
 }
@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu.Judgements;
+
+namespace osu.Game.Rulesets.Osu.Objects
+{
+    public class SliderTailCircle : SliderCircle
+    {
+        public SliderTailCircle(Slider slider)
+            : base(slider)
+        {
+        }
+
+        public override Judgement CreateJudgement() => new OsuSliderTailJudgement();
+    }
+}
@@ -3,6 +3,8 @@

 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Osu.Judgements;

 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -26,5 +28,7 @@ namespace osu.Game.Rulesets.Osu.Objects

            TimePreempt = (StartTime - SpanStartTime) / 2 + offset;
        }
+
+        public override Judgement CreateJudgement() => new OsuJudgement();
    }
 }
@@ -5,6 +5,8 @@ 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.Osu.Judgements;

 namespace osu.Game.Rulesets.Osu.Objects
 {
@@ -18,8 +20,6 @@ namespace osu.Game.Rulesets.Osu.Objects
        /// </summary>
        public int SpinsRequired { get; protected set; } = 1;

-        public override bool NewCombo => true;
-
        protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
        {
            base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
@@ -29,5 +29,7 @@ namespace osu.Game.Rulesets.Osu.Objects
            // 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);
        }
+
+        public override Judgement CreateJudgement() => new OsuJudgement();
    }
 }
@@ -2,13 +2,11 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

 using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Extensions;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;

@@ -26,28 +24,11 @@ namespace osu.Game.Rulesets.Osu.Scoring
        private readonly Dictionary<HitResult, int> scoreResultCounts = new Dictionary<HitResult, int>();
        private readonly Dictionary<ComboResult, int> comboResultCounts = new Dictionary<ComboResult, int>();

-        protected override void SimulateAutoplay(Beatmap<OsuHitObject> beatmap)
+        protected override void ApplyBeatmap(Beatmap<OsuHitObject> beatmap)
        {
+            base.ApplyBeatmap(beatmap);
+
            hpDrainRate = beatmap.BeatmapInfo.BaseDifficulty.DrainRate;
-
-            foreach (var obj in beatmap.HitObjects)
-            {
-                if (obj is Slider slider)
-                {
-                    // Head
-                    AddJudgement(new OsuJudgement { Result = HitResult.Great });
-
-                    // Ticks
-                    foreach (var unused in slider.NestedHitObjects.OfType<SliderTick>())
-                        AddJudgement(new OsuJudgement { Result = HitResult.Great });
-
-                    //Repeats
-                    foreach (var unused in slider.NestedHitObjects.OfType<RepeatPoint>())
-                        AddJudgement(new OsuJudgement { Result = HitResult.Great });
-                }
-
-                AddJudgement(new OsuJudgement { Result = HitResult.Great });
-            }
        }

        protected override void Reset(bool storeResults)
@@ -70,19 +51,19 @@ namespace osu.Game.Rulesets.Osu.Scoring

        private const double harshness = 0.01;

-        protected override void OnNewJudgement(Judgement judgement)
+        protected override void ApplyResult(JudgementResult result)
        {
-            base.OnNewJudgement(judgement);
+            base.ApplyResult(result);

-            var osuJudgement = (OsuJudgement)judgement;
+            var osuResult = (OsuJudgementResult)result;

-            if (judgement.Result != HitResult.None)
+            if (result.Type != HitResult.None)
            {
-                scoreResultCounts[judgement.Result] = scoreResultCounts.GetOrDefault(judgement.Result) + 1;
-                comboResultCounts[osuJudgement.Combo] = comboResultCounts.GetOrDefault(osuJudgement.Combo) + 1;
+                scoreResultCounts[result.Type] = scoreResultCounts.GetOrDefault(result.Type) + 1;
+                comboResultCounts[osuResult.ComboType] = comboResultCounts.GetOrDefault(osuResult.ComboType) + 1;
            }

-            switch (judgement.Result)
+            switch (result.Type)
            {
                case HitResult.Great:
                    Health.Value += (10.2 - hpDrainRate) * harshness;
@@ -105,5 +86,7 @@ namespace osu.Game.Rulesets.Osu.Scoring
                    break;
            }
        }
+
+        protected override JudgementResult CreateResult(Judgement judgement) => new OsuJudgementResult(judgement);
    }
 }
@@ -50,7 +50,7 @@ namespace osu.Game.Rulesets.Osu.UI

        public override void Add(DrawableHitObject h)
        {
-            h.OnJudgement += onJudgement;
+            h.OnNewResult += onNewResult;

            var c = h as IDrawableHitObjectWithProxiedApproach;
            if (c != null)
@@ -64,12 +64,12 @@ namespace osu.Game.Rulesets.Osu.UI
            connectionLayer.HitObjects = HitObjects.Objects.Select(d => d.HitObject).OfType<OsuHitObject>();
        }

-        private void onJudgement(DrawableHitObject judgedObject, Judgement judgement)
+        private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
        {
-            if (!judgedObject.DisplayJudgement || !DisplayJudgements)
+            if (!judgedObject.DisplayResult || !DisplayJudgements)
                return;

-            DrawableOsuJudgement explosion = new DrawableOsuJudgement(judgement, judgedObject)
+            DrawableOsuJudgement explosion = new DrawableOsuJudgement(result, judgedObject)
            {
                Origin = Anchor.Centre,
                Position = ((OsuHitObject)judgedObject.HitObject).StackedEndPosition
@@ -8,9 +8,9 @@ using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.MathUtils;
-using osu.Framework.Timing;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Taiko.Judgements;
@@ -39,8 +39,10 @@ namespace osu.Game.Rulesets.Taiko.Tests
        [BackgroundDependencyLoader]
        private void load()
        {
-            AddStep("Hit!", () => addHitJudgement(false));
+            AddStep("Hit", () => addHitJudgement(false));
+            AddStep("Strong hit", () => addStrongHitJudgement(false));
            AddStep("Kiai hit", () => addHitJudgement(true));
+            AddStep("Strong kiai hit", () => addStrongHitJudgement(true));
            AddStep("Miss :(", addMissJudgement);
            AddStep("DrumRoll", () => addDrumRoll(false));
            AddStep("Strong DrumRoll", () => addDrumRoll(true));
@@ -78,15 +80,12 @@ namespace osu.Game.Rulesets.Taiko.Tests
                ControlPointInfo = controlPointInfo
            });

-            var rateAdjustClock = new StopwatchClock(true) { Rate = 1 };
-
            Add(playfieldContainer = new Container
            {
                Anchor = Anchor.Centre,
                Origin = Anchor.Centre,
                RelativeSizeAxes = Axes.X,
                Height = 768,
-                Clock = new FramedClock(rateAdjustClock),
                Children = new[] { rulesetContainer = new TaikoRulesetContainer(new TaikoRuleset(), beatmap) }
            });
        }
@@ -133,28 +132,35 @@ namespace osu.Game.Rulesets.Taiko.Tests
            HitResult hitResult = RNG.Next(2) == 0 ? HitResult.Good : HitResult.Great;

            var cpi = new ControlPointInfo();
-            cpi.EffectPoints.Add(new EffectControlPoint
-            {
-                KiaiMode = kiai
-            });
+            cpi.EffectPoints.Add(new EffectControlPoint { KiaiMode = kiai });

            Hit hit = new Hit();
            hit.ApplyDefaults(cpi, new BeatmapDifficulty());

            var h = new DrawableTestHit(hit) { X = RNG.NextSingle(hitResult == HitResult.Good ? -0.1f : -0.05f, hitResult == HitResult.Good ? 0.1f : 0.05f) };

-            ((TaikoPlayfield)rulesetContainer.Playfield).OnJudgement(h, new TaikoJudgement { Result = hitResult });
+            ((TaikoPlayfield)rulesetContainer.Playfield).OnNewResult(h, new JudgementResult(new TaikoJudgement()) { Type = hitResult });
+        }

-            if (RNG.Next(10) == 0)
-            {
-                ((TaikoPlayfield)rulesetContainer.Playfield).OnJudgement(h, new TaikoJudgement { Result = hitResult });
-                ((TaikoPlayfield)rulesetContainer.Playfield).OnJudgement(h, new TaikoStrongHitJudgement());
-            }
+        private void addStrongHitJudgement(bool kiai)
+        {
+            HitResult hitResult = RNG.Next(2) == 0 ? HitResult.Good : HitResult.Great;
+
+            var cpi = new ControlPointInfo();
+            cpi.EffectPoints.Add(new EffectControlPoint { KiaiMode = kiai });
+
+            Hit hit = new Hit();
+            hit.ApplyDefaults(cpi, new BeatmapDifficulty());
+
+            var h = new DrawableTestHit(hit) { X = RNG.NextSingle(hitResult == HitResult.Good ? -0.1f : -0.05f, hitResult == HitResult.Good ? 0.1f : 0.05f) };
+
+            ((TaikoPlayfield)rulesetContainer.Playfield).OnNewResult(h, new JudgementResult(new TaikoJudgement()) { Type = hitResult });
+            ((TaikoPlayfield)rulesetContainer.Playfield).OnNewResult(new TestStrongNestedHit(h), new JudgementResult(new TaikoStrongJudgement()) { Type = HitResult.Great });
        }

        private void addMissJudgement()
        {
-            ((TaikoPlayfield)rulesetContainer.Playfield).OnJudgement(new DrawableTestHit(new Hit()), new TaikoJudgement { Result = HitResult.Miss });
+            ((TaikoPlayfield)rulesetContainer.Playfield).OnNewResult(new DrawableTestHit(new Hit()), new JudgementResult(new TaikoJudgement()) { Type = HitResult.Miss });
        }

        private void addBarLine(bool major, double delay = scroll_time)
@@ -204,10 +210,7 @@ namespace osu.Game.Rulesets.Taiko.Tests

            h.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());

-            if (strong)
-                rulesetContainer.Playfield.Add(new DrawableCentreHitStrong(h));
-            else
-                rulesetContainer.Playfield.Add(new DrawableCentreHit(h));
+            rulesetContainer.Playfield.Add(new DrawableCentreHit(h));
        }

        private void addRimHit(bool strong)
@@ -220,10 +223,17 @@ namespace osu.Game.Rulesets.Taiko.Tests

            h.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());

-            if (strong)
-                rulesetContainer.Playfield.Add(new DrawableRimHitStrong(h));
-            else
-                rulesetContainer.Playfield.Add(new DrawableRimHit(h));
+            rulesetContainer.Playfield.Add(new DrawableRimHit(h));
+        }
+
+        private class TestStrongNestedHit : DrawableStrongNestedHit
+        {
+            public TestStrongNestedHit(DrawableHitObject mainObject)
+                : base(null, mainObject)
+            {
+            }
+
+            public override bool OnPressed(TaikoAction action) => false;
        }

        private class DrawableTestHit : DrawableHitObject<TaikoHitObject>
@@ -168,7 +168,6 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                {
                    StartTime = obj.StartTime,
                    Samples = obj.Samples,
-                    IsStrong = strong,
                    Duration = endTimeData.Duration,
                    RequiredHits = (int)Math.Max(1, endTimeData.Duration / 1000 * hitMultiplier)
                };
@@ -7,15 +7,10 @@ namespace osu.Game.Rulesets.Taiko.Judgements
 {
    public class TaikoIntermediateSwellJudgement : TaikoJudgement
    {
-        public override HitResult MaxResult => HitResult.Perfect;
+        public override HitResult MaxResult => HitResult.Great;

        public override bool AffectsCombo => false;

-        public TaikoIntermediateSwellJudgement()
-        {
-            Final = false;
-        }
-
        /// <summary>
        /// Computes the numeric result value for the combo portion of the score.
        /// </summary>
@@ -3,13 +3,8 @@

 namespace osu.Game.Rulesets.Taiko.Judgements
 {
-    public class TaikoStrongHitJudgement : TaikoJudgement
+    public class TaikoStrongJudgement : TaikoJudgement
    {
        public override bool AffectsCombo => false;
-
-        public TaikoStrongHitJudgement()
-        {
-            Final = true;
-        }
    }
 }
@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
    public class DrawableCentreHit : DrawableHit
    {
-        protected override TaikoAction[] HitActions { get; } = { TaikoAction.LeftCentre, TaikoAction.RightCentre };
+        public override TaikoAction[] HitActions { get; } = { TaikoAction.LeftCentre, TaikoAction.RightCentre };

        public DrawableCentreHit(Hit hit)
            : base(hit)
@@ -1,26 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Allocation;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
-
-namespace osu.Game.Rulesets.Taiko.Objects.Drawables
-{
-    public class DrawableCentreHitStrong : DrawableHitStrong
-    {
-        protected override TaikoAction[] HitActions { get; } = { TaikoAction.LeftCentre, TaikoAction.RightCentre };
-
-        public DrawableCentreHitStrong(Hit hit)
-            : base(hit)
-        {
-            MainPiece.Add(new CentreHitSymbolPiece());
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            MainPiece.AccentColour = colours.PinkDarker;
-        }
-    }
-}
@@ -6,7 +6,6 @@ using osu.Framework.Allocation;
 using osu.Framework.MathUtils;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Taiko.Judgements;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
@@ -40,7 +39,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
            foreach (var tick in drumRoll.NestedHitObjects.OfType<DrumRollTick>())
            {
                var newTick = new DrawableDrumRollTick(tick);
-                newTick.OnJudgement += onTickJudgement;
+                newTick.OnNewResult += onNewTickResult;

                AddNested(newTick);
                tickContainer.Add(newTick);
@@ -61,9 +60,9 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
            colourEngaged = colours.YellowDarker;
        }

-        private void onTickJudgement(DrawableHitObject obj, Judgement judgement)
+        private void onNewTickResult(DrawableHitObject obj, JudgementResult result)
        {
-            if (judgement.Result > HitResult.Miss)
+            if (result.Type > HitResult.Miss)
                rollingHits++;
            else
                rollingHits--;
@@ -74,7 +73,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
            MainPiece.FadeAccent(newColour, 100);
        }

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (userTriggered)
                return;
@@ -84,13 +83,9 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables

            int countHit = NestedHitObjects.Count(o => o.IsHit);
            if (countHit >= HitObject.RequiredGoodHits)
-            {
-                AddJudgement(new TaikoJudgement { Result = countHit >= HitObject.RequiredGreatHits ? HitResult.Great : HitResult.Good });
-                if (HitObject.IsStrong)
-                    AddJudgement(new TaikoStrongHitJudgement());
-            }
+                ApplyResult(r => r.Type = countHit >= HitObject.RequiredGreatHits ? HitResult.Great : HitResult.Good);
            else
-                AddJudgement(new TaikoJudgement { Result = HitResult.Miss });
+                ApplyResult(r => r.Type = HitResult.Miss);
        }

        protected override void UpdateState(ArmedState state)
@@ -103,5 +98,25 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                    break;
            }
        }
+
+        protected override DrawableStrongNestedHit CreateStrongHit(StrongHitObject hitObject) => new StrongNestedHit(hitObject, this);
+
+        private class StrongNestedHit : DrawableStrongNestedHit
+        {
+            public StrongNestedHit(StrongHitObject strong, DrawableDrumRoll drumRoll)
+                : base(strong, drumRoll)
+            {
+            }
+
+            protected override void CheckForResult(bool userTriggered, double timeOffset)
+            {
+                if (!MainObject.Judged)
+                    return;
+
+                ApplyResult(r => r.Type = MainObject.IsHit ? HitResult.Great : HitResult.Miss);
+            }
+
+            public override bool OnPressed(TaikoAction action) => false;
+        }
    }
 }
@@ -5,7 +5,6 @@ using System;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Taiko.Judgements;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;

 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
@@ -18,24 +17,26 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
            FillMode = FillMode.Fit;
        }

-        public override bool DisplayJudgement => false;
+        public override bool DisplayResult => false;

        protected override TaikoPiece CreateMainPiece() => new TickPiece
        {
            Filled = HitObject.FirstTick
        };

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (!userTriggered)
+            {
+                if (timeOffset > HitObject.HitWindow)
+                    ApplyResult(r => r.Type = HitResult.Miss);
+                return;
+            }
+
+            if (Math.Abs(timeOffset) > HitObject.HitWindow)
                return;

-            if (!(Math.Abs(timeOffset) < HitObject.HitWindow))
-                return;
-
-            AddJudgement(new TaikoDrumRollTickJudgement { Result = HitResult.Great });
-            if (HitObject.IsStrong)
-                AddJudgement(new TaikoStrongHitJudgement());
+            ApplyResult(r => r.Type = HitResult.Great);
        }

        protected override void UpdateState(ArmedState state)
@@ -48,6 +49,26 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
            }
        }

-        public override bool OnPressed(TaikoAction action) => UpdateJudgement(true);
+        public override bool OnPressed(TaikoAction action) => UpdateResult(true);
+
+        protected override DrawableStrongNestedHit CreateStrongHit(StrongHitObject hitObject) => new StrongNestedHit(hitObject, this);
+
+        private class StrongNestedHit : DrawableStrongNestedHit
+        {
+            public StrongNestedHit(StrongHitObject strong, DrawableDrumRollTick tick)
+                : base(strong, tick)
+            {
+            }
+
+            protected override void CheckForResult(bool userTriggered, double timeOffset)
+            {
+                if (!MainObject.Judged)
+                    return;
+
+                ApplyResult(r => r.Type = MainObject.IsHit ? HitResult.Great : HitResult.Miss);
+            }
+
+            public override bool OnPressed(TaikoAction action) => false;
+        }
    }
 }
@@ -1,11 +1,11 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using System;
 using System.Linq;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Taiko.Judgements;
 using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;

 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
@@ -15,17 +15,14 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
        /// <summary>
        /// A list of keys which can result in hits for this HitObject.
        /// </summary>
-        protected abstract TaikoAction[] HitActions { get; }
+        public abstract TaikoAction[] HitActions { get; }

        /// <summary>
-        /// Whether a second hit is allowed to be processed. This occurs once this hit object has been hit successfully.
+        /// The action that caused this <see cref="DrawableHit"/> to be hit.
        /// </summary>
-        protected bool SecondHitAllowed { get; private set; }
+        public TaikoAction? HitAction { get; private set; }

-        /// <summary>
-        /// Whether the last key pressed is a valid hit key.
-        /// </summary>
-        private bool validKeyPressed;
+        private bool validActionPressed;

        protected DrawableHit(Hit hit)
            : base(hit)
@@ -33,12 +30,12 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
            FillMode = FillMode.Fit;
        }

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (!userTriggered)
            {
                if (!HitObject.HitWindows.CanBeHit(timeOffset))
-                    AddJudgement(new TaikoJudgement { Result = HitResult.Miss });
+                    ApplyResult(r => r.Type = HitResult.Miss);
                return;
            }

@@ -46,26 +43,33 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
            if (result == HitResult.None)
                return;

-            if (!validKeyPressed || result == HitResult.Miss)
-                AddJudgement(new TaikoJudgement { Result = HitResult.Miss });
+            if (!validActionPressed)
+                ApplyResult(r => r.Type = HitResult.Miss);
            else
-            {
-                AddJudgement(new TaikoJudgement
-                {
-                    Result = result,
-                    Final = !HitObject.IsStrong
-                });
-
-                SecondHitAllowed = true;
-            }
+                ApplyResult(r => r.Type = result);
        }

        public override bool OnPressed(TaikoAction action)
        {
-            validKeyPressed = HitActions.Contains(action);
+            if (Judged)
+                return false;
+
+            validActionPressed = HitActions.Contains(action);

            // Only count this as handled if the new judgement is a hit
-            return UpdateJudgement(true);
+            var result = UpdateResult(true);
+
+            if (IsHit)
+                HitAction = action;
+
+            return result;
+        }
+
+        public override bool OnReleased(TaikoAction action)
+        {
+            if (action == HitAction)
+                HitAction = null;
+            return base.OnReleased(action);
        }

        protected override void Update()
@@ -86,8 +90,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                switch (State.Value)
                {
                    case ArmedState.Idle:
-                        SecondHitAllowed = false;
-                        validKeyPressed = false;
+                        validActionPressed = false;

                        UnproxyContent();
                        this.Delay(HitObject.HitWindows.HalfWindowFor(HitResult.Miss)).Expire();
@@ -123,5 +126,65 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                }
            }
        }
+
+        protected override DrawableStrongNestedHit CreateStrongHit(StrongHitObject hitObject) => new StrongNestedHit(hitObject, this);
+
+        private class StrongNestedHit : DrawableStrongNestedHit
+        {
+            /// <summary>
+            /// The lenience for the second key press.
+            /// This does not adjust by map difficulty in ScoreV2 yet.
+            /// </summary>
+            private const double second_hit_window = 30;
+
+            public new DrawableHit MainObject => (DrawableHit)base.MainObject;
+
+            public StrongNestedHit(StrongHitObject strong, DrawableHit hit)
+                : base(strong, hit)
+            {
+            }
+
+            protected override void CheckForResult(bool userTriggered, double timeOffset)
+            {
+                if (!MainObject.Result.HasResult)
+                {
+                    base.CheckForResult(userTriggered, timeOffset);
+                    return;
+                }
+
+                if (!MainObject.Result.IsHit)
+                {
+                    ApplyResult(r => r.Type = HitResult.Miss);
+                    return;
+                }
+
+                if (!userTriggered)
+                {
+                    if (timeOffset > second_hit_window)
+                        ApplyResult(r => r.Type = HitResult.Miss);
+                    return;
+                }
+
+                if (Math.Abs(MainObject.Result.TimeOffset - timeOffset) < second_hit_window)
+                    ApplyResult(r => r.Type = HitResult.Great);
+            }
+
+            public override bool OnPressed(TaikoAction action)
+            {
+                // Don't process actions until the main hitobject is hit
+                if (!MainObject.IsHit)
+                    return false;
+
+                // Don't process actions if the pressed button was released
+                if (MainObject.HitAction == null)
+                    return false;
+
+                // Don't handle invalid hit action presses
+                if (!MainObject.HitActions.Contains(action))
+                    return false;
+
+                return UpdateResult(true);
+            }
+        }
    }
 }
@@ -1,103 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using System;
-using System.Linq;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Scoring;
-using osu.Game.Rulesets.Taiko.Judgements;
-
-namespace osu.Game.Rulesets.Taiko.Objects.Drawables
-{
-    public abstract class DrawableHitStrong : DrawableHit
-    {
-        /// <summary>
-        /// The lenience for the second key press.
-        /// This does not adjust by map difficulty in ScoreV2 yet.
-        /// </summary>
-        private const double second_hit_window = 30;
-
-        private double firstHitTime;
-        private bool firstKeyHeld;
-        private TaikoAction firstHitAction;
-
-        protected DrawableHitStrong(Hit hit)
-            : base(hit)
-        {
-        }
-
-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
-        {
-            if (!SecondHitAllowed)
-            {
-                base.CheckForJudgements(userTriggered, timeOffset);
-                return;
-            }
-
-            if (!userTriggered)
-            {
-                if (timeOffset > second_hit_window)
-                    AddJudgement(new TaikoStrongHitJudgement { Result = HitResult.None });
-                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 });
-        }
-
-        protected override void UpdateState(ArmedState state)
-        {
-            base.UpdateState(state);
-
-            switch (state)
-            {
-                case ArmedState.Idle:
-                    firstHitTime = 0;
-                    firstKeyHeld = false;
-                    break;
-            }
-        }
-
-        public override bool OnReleased(TaikoAction action)
-        {
-            if (action == firstHitAction)
-                firstKeyHeld = false;
-            return base.OnReleased(action);
-        }
-
-        public override bool OnPressed(TaikoAction action)
-        {
-            if (AllJudged)
-                return false;
-
-            // Check if we've handled the first key
-            if (!SecondHitAllowed)
-            {
-                // First key hasn't been handled yet, attempt to handle it
-                bool handled = base.OnPressed(action);
-
-                if (handled)
-                {
-                    firstHitTime = Time.Current;
-                    firstHitAction = action;
-                    firstKeyHeld = true;
-                }
-
-                return handled;
-            }
-
-            // Don't handle represses of the first key
-            if (firstHitAction == action)
-                return false;
-
-            // Don't handle invalid hit action presses
-            if (!HitActions.Contains(action))
-                return false;
-
-            // Assume the intention was to hit the strong hit with both keys only if the first key is still being held down
-            return firstKeyHeld && UpdateJudgement(true);
-        }
-    }
-}
@@ -9,7 +9,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
    public class DrawableRimHit : DrawableHit
    {
-        protected override TaikoAction[] HitActions { get; } = { TaikoAction.LeftRim, TaikoAction.RightRim };
+        public override TaikoAction[] HitActions { get; } = { TaikoAction.LeftRim, TaikoAction.RightRim };

        public DrawableRimHit(Hit hit)
            : base(hit)
@@ -1,26 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Allocation;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
-
-namespace osu.Game.Rulesets.Taiko.Objects.Drawables
-{
-    public class DrawableRimHitStrong : DrawableHitStrong
-    {
-        protected override TaikoAction[] HitActions { get; } = { TaikoAction.LeftRim, TaikoAction.RightRim };
-
-        public DrawableRimHitStrong(Hit hit)
-            : base(hit)
-        {
-            MainPiece.Add(new RimHitSymbolPiece());
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            MainPiece.AccentColour = colours.BlueDarker;
-        }
-    }
-}
@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2018 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;
+using osu.Game.Rulesets.Taiko.Judgements;
+
+namespace osu.Game.Rulesets.Taiko.Objects.Drawables
+{
+    /// <summary>
+    /// Used as a nested hitobject to provide <see cref="TaikoStrongJudgement"/>s for <see cref="DrawableTaikoHitObject"/>s.
+    /// </summary>
+    public abstract class DrawableStrongNestedHit : DrawableTaikoHitObject
+    {
+        public readonly DrawableHitObject MainObject;
+
+        protected DrawableStrongNestedHit(StrongHitObject strong, DrawableHitObject mainObject)
+            : base(strong)
+        {
+            MainObject = mainObject;
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+        }
+    }
+}
@@ -2,6 +2,8 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

 using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
@@ -12,23 +14,19 @@ using osu.Game.Rulesets.Taiko.Objects.Drawables.Pieces;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Taiko.Judgements;
 using osu.Game.Rulesets.Scoring;

 namespace osu.Game.Rulesets.Taiko.Objects.Drawables
 {
    public class DrawableSwell : DrawableTaikoHitObject<Swell>
    {
-        /// <summary>
-        /// A judgement is only displayed when the user has complete the swell (either a hit or miss).
-        /// </summary>
-        public override bool DisplayJudgement => AllJudged;
-
        private const float target_ring_thick_border = 1.4f;
        private const float target_ring_thin_border = 1f;
        private const float target_ring_scale = 5f;
        private const float inner_ring_alpha = 0.65f;

+        private readonly List<DrawableSwellTick> ticks = new List<DrawableSwellTick>();
+
        private readonly Container bodyContainer;
        private readonly CircularContainer targetRing;
        private readonly CircularContainer expandingRing;
@@ -106,6 +104,15 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
            });

            MainPiece.Add(symbol = new SwellSymbolPiece());
+
+            foreach (var tick in HitObject.NestedHitObjects.OfType<SwellTick>())
+            {
+                var vis = new DrawableSwellTick(tick);
+
+                ticks.Add(vis);
+                AddInternal(vis);
+                AddNested(vis);
+            }
        }

        [BackgroundDependencyLoader]
@@ -124,13 +131,17 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
            Width *= Parent.RelativeChildSize.X;
        }

-        protected override void CheckForJudgements(bool userTriggered, double timeOffset)
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
        {
            if (userTriggered)
            {
-                AddJudgement(new TaikoIntermediateSwellJudgement());
+                var nextTick = ticks.FirstOrDefault(j => !j.IsHit);

-                var completion = (float)Judgements.Count / HitObject.RequiredHits;
+                nextTick?.TriggerResult(HitResult.Great);
+
+                var numHits = ticks.Count(r => r.IsHit);
+
+                var completion = (float)numHits / HitObject.RequiredHits;

                expandingRing
                    .FadeTo(expandingRing.Alpha + MathHelper.Clamp(completion / 16, 0.1f, 0.6f), 50)
@@ -141,18 +152,30 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables

                expandingRing.ScaleTo(1f + Math.Min(target_ring_scale - 1f, (target_ring_scale - 1f) * completion * 1.3f), 260, Easing.OutQuint);

-                if (Judgements.Count == HitObject.RequiredHits)
-                    AddJudgement(new TaikoJudgement { Result = HitResult.Great });
+                if (numHits == HitObject.RequiredHits)
+                    ApplyResult(r => r.Type = HitResult.Great);
            }
            else
            {
                if (timeOffset < 0)
                    return;

-                //TODO: THIS IS SHIT AND CAN'T EXIST POST-TAIKO WORLD CUP
-                AddJudgement(Judgements.Count > HitObject.RequiredHits / 2
-                    ? new TaikoJudgement { Result = HitResult.Good }
-                    : new TaikoJudgement { Result = HitResult.Miss });
+                int numHits = 0;
+
+                foreach (var tick in ticks)
+                {
+                    if (tick.IsHit)
+                    {
+                        numHits++;
+                        continue;
+                    }
+
+                    tick.TriggerResult(HitResult.Miss);
+                }
+
+                var hitResult = numHits > HitObject.RequiredHits / 2 ? HitResult.Good : HitResult.Miss;
+
+                ApplyResult(r => r.Type = hitResult);
            }
        }

@@ -208,7 +231,7 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
                return false;
            lastWasCentre = isCentre;

-            UpdateJudgement(true);
+            UpdateResult(true);

            return true;
        }
@@ -0,0 +1,30 @@
+// Copyright (c) 2007-2018 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;
+using osu.Game.Rulesets.Scoring;
+
+namespace osu.Game.Rulesets.Taiko.Objects.Drawables
+{
+    public class DrawableSwellTick : DrawableTaikoHitObject
+    {
+        public override bool DisplayResult => false;
+
+        public DrawableSwellTick(TaikoHitObject hitObject)
+            : base(hitObject)
+        {
+        }
+
+        public void TriggerResult(HitResult type) => ApplyResult(r => r.Type = type);
+
+        protected override void CheckForResult(bool userTriggered, double timeOffset)
+        {
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+        }
+
+        public override bool OnPressed(TaikoAction action) => false;
+    }
+}
@@ -101,6 +101,15 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables

            Content.Add(MainPiece = CreateMainPiece());
            MainPiece.KiaiMode = HitObject.Kiai;
+
+            var strongObject = HitObject.NestedHitObjects.OfType<StrongHitObject>().FirstOrDefault();
+            if (strongObject != null)
+            {
+                var strongHit = CreateStrongHit(strongObject);
+
+                AddNested(strongHit);
+                AddInternal(strongHit);
+            }
        }

        // Normal and clap samples are handled by the drum
@@ -109,5 +118,13 @@ namespace osu.Game.Rulesets.Taiko.Objects.Drawables
        protected override string SampleNamespace => "Taiko";

        protected virtual TaikoPiece CreateMainPiece() => new CirclePiece();
+
+        /// <summary>
+        /// Creates the handler for this <see cref="DrawableHitObject"/>'s <see cref="StrongHitObject"/>.
+        /// This is only invoked if <see cref="TaikoHitObject.IsStrong"/> is true for <see cref="HitObject"/>.
+        /// </summary>
+        /// <param name="hitObject">The strong hitobject.</param>
+        /// <returns>The strong hitobject handler.</returns>
+        protected virtual DrawableStrongNestedHit CreateStrongHit(StrongHitObject hitObject) => null;
    }
 }
@@ -54,12 +54,12 @@ namespace osu.Game.Rulesets.Taiko.Objects

        protected override void CreateNestedHitObjects()
        {
-            base.CreateNestedHitObjects();
-
            createTicks();

            RequiredGoodHits = NestedHitObjects.Count * Math.Min(0.15, 0.05 + 0.10 / 6 * overallDifficulty);
            RequiredGreatHits = NestedHitObjects.Count * Math.Min(0.30, 0.10 + 0.20 / 6 * overallDifficulty);
+
+            base.CreateNestedHitObjects();
        }

        private void createTicks()
@@ -1,6 +1,9 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Taiko.Judgements;
+
 namespace osu.Game.Rulesets.Taiko.Objects
 {
    public class DrumRollTick : TaikoHitObject
@@ -20,5 +23,7 @@ namespace osu.Game.Rulesets.Taiko.Objects
        /// The time allowed to hit this tick.
        /// </summary>
        public double HitWindow => TickSpacing / 2;
+
+        public override Judgement CreateJudgement() => new TaikoDrumRollTickJudgement();
    }
 }
@@ -0,0 +1,13 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Taiko.Judgements;
+
+namespace osu.Game.Rulesets.Taiko.Objects
+{
+    public class StrongHitObject : TaikoHitObject
+    {
+        public override Judgement CreateJudgement() => new TaikoStrongJudgement();
+    }
+}
@@ -1,6 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using System;
 using osu.Game.Rulesets.Objects.Types;

 namespace osu.Game.Rulesets.Taiko.Objects
@@ -15,5 +16,15 @@ namespace osu.Game.Rulesets.Taiko.Objects
        /// The number of hits required to complete the swell successfully.
        /// </summary>
        public int RequiredHits = 10;
+
+        public override bool IsStrong { set => throw new NotSupportedException($"{nameof(Swell)} cannot be a strong hitobject."); }
+
+        protected override void CreateNestedHitObjects()
+        {
+            base.CreateNestedHitObjects();
+
+            for (int i = 0; i < RequiredHits; i++)
+                AddNested(new SwellTick());
+        }
    }
 }
@@ -0,0 +1,9 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Taiko.Objects
+{
+    public class SwellTick : TaikoHitObject
+    {
+    }
+}
@@ -1,7 +1,10 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Taiko.Judgements;

 namespace osu.Game.Rulesets.Taiko.Objects
 {
@@ -26,7 +29,17 @@ namespace osu.Game.Rulesets.Taiko.Objects
        /// Whether this HitObject is a "strong" type.
        /// Strong hit objects give more points for hitting the hit object with both keys.
        /// </summary>
-        public bool IsStrong;
+        public virtual bool IsStrong { get; set; }
+
+        protected override void CreateNestedHitObjects()
+        {
+            base.CreateNestedHitObjects();
+
+            if (IsStrong)
+                AddNested(new StrongHitObject { StartTime = (this as IHasEndTime)?.EndTime ?? StartTime });
+        }
+
+        public override Judgement CreateJudgement() => new TaikoJudgement();

        protected override HitWindows CreateHitWindows() => new TaikoHitWindows();
    }
@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

-using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Scoring;
@@ -60,63 +59,31 @@ namespace osu.Game.Rulesets.Taiko.Scoring
        private double hpIncreaseGood;
        private double hpIncreaseMiss;

-        public TaikoScoreProcessor()
-        {
-        }
-
        public TaikoScoreProcessor(RulesetContainer<TaikoHitObject> rulesetContainer)
            : base(rulesetContainer)
        {
        }

-        protected override void SimulateAutoplay(Beatmap<TaikoHitObject> beatmap)
+        protected override void ApplyBeatmap(Beatmap<TaikoHitObject> beatmap)
        {
+            base.ApplyBeatmap(beatmap);
+
            double hpMultiplierNormal = 1 / (hp_hit_great * beatmap.HitObjects.FindAll(o => o is Hit).Count * BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.DrainRate, 0.5, 0.75, 0.98));

            hpIncreaseTick = hp_hit_tick;
            hpIncreaseGreat = hpMultiplierNormal * hp_hit_great;
            hpIncreaseGood = hpMultiplierNormal * hp_hit_good;
            hpIncreaseMiss = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.DrainRate, hp_miss_min, hp_miss_mid, hp_miss_max);
-
-            foreach (var obj in beatmap.HitObjects)
-            {
-                switch (obj)
-                {
-                    case Hit _:
-                        AddJudgement(new TaikoJudgement { Result = HitResult.Great });
-                        if (obj.IsStrong)
-                            AddJudgement(new TaikoStrongHitJudgement());
-                        break;
-                    case DrumRoll drumRoll:
-                        var count = drumRoll.NestedHitObjects.OfType<DrumRollTick>().Count();
-                        for (int i = 0; i < count; i++)
-                        {
-                            AddJudgement(new TaikoDrumRollTickJudgement { Result = HitResult.Great });
-
-                            if (obj.IsStrong)
-                                AddJudgement(new TaikoStrongHitJudgement());
-                        }
-
-                        AddJudgement(new TaikoJudgement { Result = HitResult.Great });
-
-                        if (obj.IsStrong)
-                            AddJudgement(new TaikoStrongHitJudgement());
-                        break;
-                    case Swell _:
-                        AddJudgement(new TaikoJudgement { Result = HitResult.Great });
-                        break;
-                }
-            }
        }

-        protected override void OnNewJudgement(Judgement judgement)
+        protected override void ApplyResult(JudgementResult result)
        {
-            base.OnNewJudgement(judgement);
+            base.ApplyResult(result);

-            bool isTick = judgement is TaikoDrumRollTickJudgement;
+            bool isTick = result.Judgement is TaikoDrumRollTickJudgement;

            // Apply HP changes
-            switch (judgement.Result)
+            switch (result.Type)
            {
                case HitResult.Miss:
                    // Missing ticks shouldn't drop HP
@@ -19,16 +19,16 @@ namespace osu.Game.Rulesets.Taiko.UI
        /// Creates a new judgement text.
        /// </summary>
        /// <param name="judgedObject">The object which is being judged.</param>
-        /// <param name="judgement">The judgement to visualise.</param>
-        public DrawableTaikoJudgement(Judgement judgement, DrawableHitObject judgedObject)
-            : base(judgement, judgedObject)
+        /// <param name="result">The judgement to visualise.</param>
+        public DrawableTaikoJudgement(JudgementResult result, DrawableHitObject judgedObject)
+            : base(result, judgedObject)
        {
        }

        [BackgroundDependencyLoader]
        private void load(OsuColour colours)
        {
-            switch (Judgement.Result)
+            switch (Result.Type)
            {
                case HitResult.Good:
                    Colour = colours.GreenLight;
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Taiko.UI

        protected override void LoadComplete()
        {
-            if (Judgement.IsHit)
+            if (Result.IsHit)
                this.MoveToY(-100, 500);

            base.LoadComplete();
@@ -209,7 +209,7 @@ namespace osu.Game.Rulesets.Taiko.UI

        public override void Add(DrawableHitObject h)
        {
-            h.OnJudgement += OnJudgement;
+            h.OnNewResult += OnNewResult;

            base.Add(h);

@@ -224,35 +224,40 @@ namespace osu.Game.Rulesets.Taiko.UI
            }
        }

-        internal void OnJudgement(DrawableHitObject judgedObject, Judgement judgement)
+        internal void OnNewResult(DrawableHitObject judgedObject, JudgementResult result)
        {
            if (!DisplayJudgements)
                return;

-            if (judgedObject.DisplayJudgement && judgementContainer.FirstOrDefault(j => j.JudgedObject == judgedObject) == null)
-            {
-                judgementContainer.Add(new DrawableTaikoJudgement(judgement, judgedObject)
-                {
-                    Anchor = judgement.IsHit ? Anchor.TopLeft : Anchor.CentreLeft,
-                    Origin = judgement.IsHit ? Anchor.BottomCentre : Anchor.Centre,
-                    RelativePositionAxes = Axes.X,
-                    X = judgement.IsHit ? judgedObject.Position.X : 0,
-                });
-            }
-
-            if (!judgement.IsHit)
+            if (!judgedObject.DisplayResult)
                return;

-            bool isRim = judgedObject.HitObject is RimHit;
-
-            if (judgement is TaikoStrongHitJudgement)
-                hitExplosionContainer.Children.FirstOrDefault(e => e.JudgedObject == judgedObject)?.VisualiseSecondHit();
-            else
+            switch (result.Judgement)
            {
-                hitExplosionContainer.Add(new HitExplosion(judgedObject, isRim));
+                case TaikoStrongJudgement _:
+                    if (result.IsHit)
+                        hitExplosionContainer.Children.FirstOrDefault(e => e.JudgedObject == ((DrawableStrongNestedHit)judgedObject).MainObject)?.VisualiseSecondHit();
+                    break;
+                default:
+                    judgementContainer.Add(new DrawableTaikoJudgement(result, judgedObject)
+                    {
+                        Anchor = result.IsHit ? Anchor.TopLeft : Anchor.CentreLeft,
+                        Origin = result.IsHit ? Anchor.BottomCentre : Anchor.Centre,
+                        RelativePositionAxes = Axes.X,
+                        X = result.IsHit ? judgedObject.Position.X : 0,
+                    });

-                if (judgedObject.HitObject.Kiai)
-                    kiaiExplosionContainer.Add(new KiaiHitExplosion(judgedObject, isRim));
+                    if (!result.IsHit)
+                        break;
+
+                    bool isRim = judgedObject.HitObject is RimHit;
+
+                    hitExplosionContainer.Add(new HitExplosion(judgedObject, isRim));
+
+                    if (judgedObject.HitObject.Kiai)
+                        kiaiExplosionContainer.Add(new KiaiHitExplosion(judgedObject, isRim));
+
+                    break;
            }
        }
    }
@@ -100,12 +100,8 @@ namespace osu.Game.Rulesets.Taiko.UI
        {
            switch (h)
            {
-                case CentreHit centreHit when h.IsStrong:
-                    return new DrawableCentreHitStrong(centreHit);
                case CentreHit centreHit:
                    return new DrawableCentreHit(centreHit);
-                case RimHit rimHit when h.IsStrong:
-                    return new DrawableRimHitStrong(rimHit);
                case RimHit rimHit:
                    return new DrawableRimHit(rimHit);
                case DrumRoll drumRoll:
@@ -11,7 +11,9 @@ using osu.Game.Audio;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Skinning;

 namespace osu.Game.Tests.Beatmaps.Formats
@@ -186,6 +188,50 @@ namespace osu.Game.Tests.Beatmaps.Formats
            }
        }

+        [Test]
+        public void TestDecodeBeatmapComboOffsetsOsu()
+        {
+            var decoder = new LegacyBeatmapDecoder();
+            using (var resStream = Resource.OpenResource("hitobject-combo-offset.osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var beatmap = decoder.Decode(stream);
+
+                var converted = new OsuBeatmapConverter(beatmap).Convert();
+                new OsuBeatmapProcessor(converted).PreProcess();
+                new OsuBeatmapProcessor(converted).PostProcess();
+
+                Assert.AreEqual(4, ((IHasComboInformation)converted.HitObjects.ElementAt(0)).ComboIndex);
+                Assert.AreEqual(5, ((IHasComboInformation)converted.HitObjects.ElementAt(2)).ComboIndex);
+                Assert.AreEqual(5, ((IHasComboInformation)converted.HitObjects.ElementAt(4)).ComboIndex);
+                Assert.AreEqual(6, ((IHasComboInformation)converted.HitObjects.ElementAt(6)).ComboIndex);
+                Assert.AreEqual(11, ((IHasComboInformation)converted.HitObjects.ElementAt(8)).ComboIndex);
+                Assert.AreEqual(14, ((IHasComboInformation)converted.HitObjects.ElementAt(11)).ComboIndex);
+            }
+        }
+
+        [Test]
+        public void TestDecodeBeatmapComboOffsetsCatch()
+        {
+            var decoder = new LegacyBeatmapDecoder();
+            using (var resStream = Resource.OpenResource("hitobject-combo-offset.osu"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var beatmap = decoder.Decode(stream);
+
+                var converted = new CatchBeatmapConverter(beatmap).Convert();
+                new CatchBeatmapProcessor(converted).PreProcess();
+                new CatchBeatmapProcessor(converted).PostProcess();
+
+                Assert.AreEqual(4, ((IHasComboInformation)converted.HitObjects.ElementAt(0)).ComboIndex);
+                Assert.AreEqual(5, ((IHasComboInformation)converted.HitObjects.ElementAt(2)).ComboIndex);
+                Assert.AreEqual(5, ((IHasComboInformation)converted.HitObjects.ElementAt(4)).ComboIndex);
+                Assert.AreEqual(6, ((IHasComboInformation)converted.HitObjects.ElementAt(6)).ComboIndex);
+                Assert.AreEqual(11, ((IHasComboInformation)converted.HitObjects.ElementAt(8)).ComboIndex);
+                Assert.AreEqual(14, ((IHasComboInformation)converted.HitObjects.ElementAt(11)).ComboIndex);
+            }
+        }
+
        [Test]
        public void TestDecodeBeatmapHitObjects()
        {
@@ -86,5 +86,19 @@ namespace osu.Game.Tests.Beatmaps.Formats
                Assert.AreEqual(78993, animation.StartTime);
            }
        }
+
+        [Test]
+        public void TestDecodeVariableWithSuffix()
+        {
+            var decoder = new LegacyStoryboardDecoder();
+            using (var resStream = Resource.OpenResource("variable-with-suffix.osb"))
+            using (var stream = new StreamReader(resStream))
+            {
+                var storyboard = decoder.Decode(stream);
+
+                StoryboardLayer background = storyboard.Layers.Single(l => l.Depth == 3);
+                Assert.AreEqual(123456, ((StoryboardSprite)background.Elements.Single()).InitialPosition.X);
+            }
+        }
    }
 }
@@ -0,0 +1,32 @@
+osu file format v14
+
+[HitObjects]
+// Circle with combo offset (3)
+255,193,1000,49,0,0:0:0:0:
+// Combo index = 4
+
+// Slider with new combo followed by circle with no new combo
+256,192,2000,12,0,2000,0:0:0:0:
+255,193,3000,1,0,0:0:0:0:
+// Combo index = 5
+
+// Slider without new combo followed by circle with no new combo
+256,192,4000,8,0,5000,0:0:0:0:
+255,193,6000,1,0,0:0:0:0:
+// Combo index = 5
+
+// Slider without new combo followed by circle with new combo
+256,192,7000,8,0,8000,0:0:0:0:
+255,193,9000,5,0,0:0:0:0:
+// Combo index = 6
+
+// Slider with new combo and offset (1) followed by circle with new combo and offset (3)
+256,192,10000,28,0,11000,0:0:0:0:
+255,193,12000,53,0,0:0:0:0:
+// Combo index = 11
+
+// Slider with new combo and offset (2) followed by slider with no new combo followed by circle with no new combo
+256,192,13000,44,0,14000,0:0:0:0:
+256,192,15000,8,0,16000,0:0:0:0:
+255,193,17000,1,0,0:0:0:0:
+// Combo index = 14
@@ -0,0 +1,5 @@
+[Variables]
+$var=1234
+
+[Events]
+Sprite,Background,TopCentre,"img.jpg",$var56,240
@@ -3,6 +3,7 @@

 using System.Collections.Generic;
 using System.Linq;
+using JetBrains.Annotations;
 using NUnit.Framework;
 using OpenTK;
 using osu.Framework.Allocation;
@@ -116,7 +117,7 @@ namespace osu.Game.Tests.Visual

        private void testNullBeatmap()
        {
-            selectNullBeatmap();
+            selectBeatmap(null);
            AddAssert("check empty version", () => string.IsNullOrEmpty(infoWedge.Info.VersionLabel.Text));
            AddAssert("check default title", () => infoWedge.Info.TitleLabel.Text == Beatmap.Default.BeatmapInfo.Metadata.Title);
            AddAssert("check default artist", () => infoWedge.Info.ArtistLabel.Text == Beatmap.Default.BeatmapInfo.Metadata.Artist);
@@ -124,28 +125,19 @@ namespace osu.Game.Tests.Visual
            AddAssert("check no info labels", () => !infoWedge.Info.InfoLabelContainer.Children.Any());
        }

-        private void selectBeatmap(IBeatmap b)
+        private void selectBeatmap([CanBeNull] IBeatmap b)
        {
            BeatmapInfoWedge.BufferedWedgeInfo infoBefore = null;

-            AddStep($"select {b.Metadata.Title} beatmap", () =>
+            AddStep($"select {b?.Metadata.Title ?? "null"} beatmap", () =>
            {
                infoBefore = infoWedge.Info;
-                infoWedge.Beatmap = Beatmap.Value = new TestWorkingBeatmap(b);
+                infoWedge.Beatmap = Beatmap.Value = b == null ? Beatmap.Default : new TestWorkingBeatmap(b);
            });

            AddUntilStep(() => infoWedge.Info != infoBefore, "wait for async load");
        }

-        private void selectNullBeatmap()
-        {
-            AddStep("select null beatmap", () =>
-            {
-                Beatmap.Value = Beatmap.Default;
-                infoWedge.Beatmap = Beatmap;
-            });
-        }
-
        private IBeatmap createTestBeatmap(RulesetInfo ruleset)
        {
            List<HitObject> objects = new List<HitObject>();
@@ -8,11 +8,15 @@ using System.Linq;
 using System.Text;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Extensions;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.Taiko;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Carousel;
 using osu.Game.Screens.Select.Filter;
@@ -29,6 +33,10 @@ namespace osu.Game.Tests.Visual
        private WorkingBeatmap defaultBeatmap;
        private DatabaseContextFactory factory;

+        [Cached]
+        [Cached(Type = typeof(IBindable<IEnumerable<Mod>>))]
+        private readonly Bindable<IEnumerable<Mod>> selectedMods = new Bindable<IEnumerable<Mod>>(new Mod[] { });
+
        public override IReadOnlyList<Type> RequiredTypes => new[]
        {
            typeof(SongSelect),
@@ -49,6 +57,8 @@ namespace osu.Game.Tests.Visual

        private class TestSongSelect : PlaySongSelect
        {
+            public new Bindable<RulesetInfo> Ruleset => base.Ruleset;
+
            public WorkingBeatmap CurrentBeatmap => Beatmap.Value;
            public WorkingBeatmap CurrentBeatmapDetailsBeatmap => BeatmapDetails.Beatmap;
            public new BeatmapCarousel Carousel => base.Carousel;
@@ -121,7 +131,7 @@ namespace osu.Game.Tests.Visual

        [Test]
        [Ignore("needs fixing")]
-        public void ImportUnderDifferentRuleset()
+        public void TestImportUnderDifferentRuleset()
        {
            changeRuleset(2);
            importForRuleset(0);
@@ -129,7 +139,7 @@ namespace osu.Game.Tests.Visual
        }

        [Test]
-        public void ImportUnderCurrentRuleset()
+        public void TestImportUnderCurrentRuleset()
        {
            changeRuleset(2);
            importForRuleset(2);
@@ -143,11 +153,42 @@ namespace osu.Game.Tests.Visual
            AddUntilStep(() => songSelect.Carousel.SelectedBeatmap == null, "no selection");
        }

+        [Test]
+        public void TestRulesetChangeResetsMods()
+        {
+            changeRuleset(0);
+
+            changeMods(new OsuModHardRock());
+
+            int actionIndex = 0;
+            int modChangeIndex = 0;
+            int rulesetChangeIndex = 0;
+
+            AddStep("change ruleset", () =>
+            {
+                songSelect.CurrentBeatmap.Mods.ValueChanged += onModChange;
+                songSelect.Ruleset.ValueChanged += onRulesetChange;
+
+                Ruleset.Value = new TaikoRuleset().RulesetInfo;
+
+                songSelect.CurrentBeatmap.Mods.ValueChanged -= onModChange;
+                songSelect.Ruleset.ValueChanged -= onRulesetChange;
+            });
+
+            AddAssert("mods changed before ruleset", () => modChangeIndex < rulesetChangeIndex);
+            AddAssert("empty mods", () => !selectedMods.Value.Any());
+
+            void onModChange(IEnumerable<Mod> mods) => modChangeIndex = actionIndex++;
+            void onRulesetChange(RulesetInfo ruleset) => rulesetChangeIndex = actionIndex--;
+        }
+
        private void importForRuleset(int id) => AddStep($"import test map for ruleset {id}", () => manager.Import(createTestBeatmapSet(getImportId(), rulesets.AvailableRulesets.Where(r => r.ID == id).ToArray())));

        private static int importId;
        private int getImportId() => ++importId;

+        private void changeMods(params Mod[] mods) => AddStep($"change mods to {string.Join(", ", mods.Select(m => m.ShortenedName))}", () => selectedMods.Value = mods);
+
        private void changeRuleset(int id) => AddStep($"change ruleset to {id}", () => Ruleset.Value = rulesets.AvailableRulesets.First(r => r.ID == id));

        private void addManyTestMaps()
@@ -329,7 +329,7 @@ namespace osu.Game.Beatmaps
                return;
            }

-            await Task.Factory.StartNew(() => Import(stable.GetDirectories("Songs")), TaskCreationOptions.LongRunning);
+            await Task.Factory.StartNew(() => Import(stable.GetDirectories("Songs").Select(f => stable.GetFullPath(f)).ToArray()), TaskCreationOptions.LongRunning);
        }

        /// <summary>
@@ -27,11 +27,10 @@ namespace osu.Game.Beatmaps
                if (obj.NewCombo)
                {
                    obj.IndexInCurrentCombo = 0;
+                    obj.ComboIndex = (lastObj?.ComboIndex ?? 0) + obj.ComboOffset + 1;
+
                    if (lastObj != null)
-                    {
                        lastObj.LastInCombo = true;
-                        obj.ComboIndex = lastObj.ComboIndex + 1;
-                    }
                }
                else if (lastObj != null)
                {
@@ -126,16 +126,16 @@ namespace osu.Game.Beatmaps.Formats
                    switch (beatmap.BeatmapInfo.RulesetID)
                    {
                        case 0:
-                            parser = new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser();
+                            parser = new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser(getOffsetTime(), FormatVersion);
                            break;
                        case 1:
-                            parser = new Rulesets.Objects.Legacy.Taiko.ConvertHitObjectParser();
+                            parser = new Rulesets.Objects.Legacy.Taiko.ConvertHitObjectParser(getOffsetTime(), FormatVersion);
                            break;
                        case 2:
-                            parser = new Rulesets.Objects.Legacy.Catch.ConvertHitObjectParser();
+                            parser = new Rulesets.Objects.Legacy.Catch.ConvertHitObjectParser(getOffsetTime(), FormatVersion);
                            break;
                        case 3:
-                            parser = new Rulesets.Objects.Legacy.Mania.ConvertHitObjectParser();
+                            parser = new Rulesets.Objects.Legacy.Mania.ConvertHitObjectParser(getOffsetTime(), FormatVersion);
                            break;
                    }

@@ -354,6 +354,11 @@ namespace osu.Game.Beatmaps.Formats

        private void handleTimingControlPoint(TimingControlPoint newPoint)
        {
+            var existing = beatmap.ControlPointInfo.TimingPointAt(newPoint.Time);
+
+            if (existing.Time == newPoint.Time)
+                beatmap.ControlPointInfo.TimingPoints.Remove(existing);
+
            beatmap.ControlPointInfo.TimingPoints.Add(newPoint);
        }

@@ -364,7 +369,9 @@ namespace osu.Game.Beatmaps.Formats
            if (newPoint.EquivalentTo(existing))
                return;

-            beatmap.ControlPointInfo.DifficultyPoints.RemoveAll(x => x.Time == newPoint.Time);
+            if (existing.Time == newPoint.Time)
+                beatmap.ControlPointInfo.DifficultyPoints.Remove(existing);
+
            beatmap.ControlPointInfo.DifficultyPoints.Add(newPoint);
        }

@@ -375,6 +382,9 @@ namespace osu.Game.Beatmaps.Formats
            if (newPoint.EquivalentTo(existing))
                return;

+            if (existing.Time == newPoint.Time)
+                beatmap.ControlPointInfo.EffectPoints.Remove(existing);
+
            beatmap.ControlPointInfo.EffectPoints.Add(newPoint);
        }

@@ -385,6 +395,9 @@ namespace osu.Game.Beatmaps.Formats
            if (newPoint.EquivalentTo(existing))
                return;

+            if (existing.Time == newPoint.Time)
+                beatmap.ControlPointInfo.SamplePoints.Remove(existing);
+
            beatmap.ControlPointInfo.SamplePoints.Add(newPoint);
        }

@@ -392,9 +405,9 @@ namespace osu.Game.Beatmaps.Formats
        {
            // If the ruleset wasn't specified, assume the osu!standard ruleset.
            if (parser == null)
-                parser = new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser();
+                parser = new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser(getOffsetTime(), FormatVersion);

-            var obj = parser.Parse(line, getOffsetTime());
+            var obj = parser.Parse(line);

            if (obj != null)
            {
@@ -289,15 +289,10 @@ namespace osu.Game.Beatmaps.Formats
            while (line.IndexOf('$') >= 0)
            {
                string origLine = line;
-                string[] split = line.Split(',');
-                for (int i = 0; i < split.Length; i++)
-                {
-                    var item = split[i];
-                    if (item.StartsWith("$") && variables.ContainsKey(item))
-                        split[i] = variables[item];
-                }

-                line = string.Join(",", split);
+                foreach (var v in variables)
+                    line = line.Replace(v.Key, v.Value);
+
                if (line == origLine)
                    break;
            }
@@ -198,6 +198,8 @@ namespace osu.Game.Database

            try
            {
+                Logger.Log($"Importing {item}...", LoggingTarget.Database);
+
                using (var write = ContextFactory.GetForWrite()) // used to share a context for full import. keep in mind this will block all writes.
                {
                    try
@@ -412,7 +414,7 @@ namespace osu.Game.Database
        private ArchiveReader getReaderFrom(string path)
        {
            if (ZipUtils.IsZipArchive(path))
-                return new ZipArchiveReader(Files.Storage.GetStream(path), Path.GetFileName(path));
+                return new ZipArchiveReader(File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read), Path.GetFileName(path));
            if (Directory.Exists(path))
                return new LegacyFilesystemReader(path);
            throw new InvalidFormatException($"{path} is not a valid archive");
@@ -36,6 +36,8 @@ using osu.Game.Skinning;
 using OpenTK.Graphics;
 using osu.Game.Overlays.Volume;
 using osu.Game.Screens.Select;
+using osu.Game.Utils;
+using LogLevel = osu.Framework.Logging.LogLevel;

 namespace osu.Game
 {
@@ -65,6 +67,8 @@ namespace osu.Game

        private ScreenshotManager screenshotManager;

+        protected RavenLogger RavenLogger;
+
        public virtual Storage GetStorageForStableInstall() => null;

        private Intro intro
@@ -108,6 +112,8 @@ namespace osu.Game
            this.args = args;

            forwardLoggedErrorsToNotifications();
+
+            RavenLogger = new RavenLogger(this);
        }

        public void ToggleSettings() => settings.ToggleVisibility();
@@ -145,13 +151,15 @@ namespace osu.Game

            if (args?.Length > 0)
            {
-                var paths = args.Where(a => !a.StartsWith(@"-"));
-
-                Task.Run(() => Import(paths.ToArray()));
+                var paths = args.Where(a => !a.StartsWith(@"-")).ToArray();
+                if (paths.Length > 0)
+                    Task.Run(() => Import(paths));
            }

            dependencies.CacheAs(this);

+            dependencies.Cache(RavenLogger);
+
            dependencies.CacheAs(ruleset);
            dependencies.CacheAs<IBindable<RulesetInfo>>(ruleset);

@@ -273,6 +281,12 @@ namespace osu.Game
            menu.Push(new PlayerLoader(new ReplayPlayer(s.Replay)));
        }

+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            RavenLogger.Dispose();
+        }
+
        protected override void LoadComplete()
        {
            // this needs to be cached before base.LoadComplete as it is used by MenuCursorContainer.
@@ -449,7 +463,7 @@ namespace osu.Game
                    Schedule(() => notifications.Post(new SimpleNotification
                    {
                        Icon = entry.Level == LogLevel.Important ? FontAwesome.fa_exclamation_circle : FontAwesome.fa_bomb,
-                        Text = entry.Message,
+                        Text = entry.Message + (entry.Exception != null && IsDeployedBuild ? "\n\nThis error has been automatically reported to the devs." : string.Empty),
                    }));
                }
                else if (recentLogCount == short_term_display_limit)
@@ -601,6 +615,7 @@ namespace osu.Game
        private void screenAdded(Screen newScreen)
        {
            currentScreen = (OsuScreen)newScreen;
+            Logger.Log($"Screen changed → {currentScreen}");

            newScreen.ModePushed += screenAdded;
            newScreen.Exited += screenRemoved;
@@ -609,6 +624,7 @@ namespace osu.Game
        private void screenRemoved(Screen newScreen)
        {
            currentScreen = (OsuScreen)newScreen;
+            Logger.Log($"Screen changed ← {currentScreen}");

            if (newScreen == null)
                Exit();
@@ -27,6 +27,11 @@ namespace osu.Game.Overlays.Mods
 {
    public class ModSelectOverlay : WaveOverlayContainer
    {
+        /// <summary>
+        /// How much this container should overflow the sides of the screen to account for parallax shifting.
+        /// </summary>
+        private const float overflow_padding = 50;
+
        private const float content_width = 0.8f;

        protected Color4 LowMultiplierColour, HighMultiplierColour;
@@ -199,6 +204,11 @@ namespace osu.Game.Overlays.Mods
            Waves.FourthWaveColour = OsuColour.FromHex(@"003a4e");

            Height = 510;
+            Padding = new MarginPadding
+            {
+                Left = -overflow_padding,
+                Right = -overflow_padding
+            };

            Children = new Drawable[]
            {
@@ -258,6 +268,11 @@ namespace osu.Game.Overlays.Mods
                                        AutoSizeAxes = Axes.Y,
                                        Direction = FillDirection.Vertical,
                                        Width = content_width,
+                                        Padding = new MarginPadding
+                                        {
+                                            Left = overflow_padding,
+                                            Right = overflow_padding
+                                        },
                                        Children = new Drawable[]
                                        {
                                            new OsuSpriteText
@@ -295,7 +310,12 @@ namespace osu.Game.Overlays.Mods
                                Origin = Anchor.TopCentre,
                                Anchor = Anchor.TopCentre,
                                RelativeSizeAxes = Axes.Both,
-                                Padding = new MarginPadding { Vertical = 10 },
+                                Padding = new MarginPadding
+                                {
+                                    Vertical = 10,
+                                    Left = overflow_padding,
+                                    Right = overflow_padding
+                                },
                                Child = ModSectionsContainer = new FillFlowContainer<ModSection>
                                {
                                    Origin = Anchor.TopCentre,
@@ -341,7 +361,9 @@ namespace osu.Game.Overlays.Mods
                                        Direction = FillDirection.Horizontal,
                                        Padding = new MarginPadding
                                        {
-                                            Vertical = 15
+                                            Vertical = 15,
+                                            Left = overflow_padding,
+                                            Right = overflow_padding
                                        },
                                        Children = new Drawable[]
                                        {
@@ -25,7 +25,7 @@ namespace osu.Game.Rulesets.Judgements

        private OsuColour colours;

-        protected readonly Judgement Judgement;
+        protected readonly JudgementResult Result;

        public readonly DrawableHitObject JudgedObject;

@@ -34,11 +34,11 @@ namespace osu.Game.Rulesets.Judgements
        /// <summary>
        /// Creates a drawable which visualises a <see cref="Judgements.Judgement"/>.
        /// </summary>
-        /// <param name="judgement">The judgement to visualise.</param>
+        /// <param name="result">The judgement to visualise.</param>
        /// <param name="judgedObject">The object which was judged.</param>
-        public DrawableJudgement(Judgement judgement, DrawableHitObject judgedObject)
+        public DrawableJudgement(JudgementResult result, DrawableHitObject judgedObject)
        {
-            Judgement = judgement;
+            Result = result;
            JudgedObject = judgedObject;

            Size = new Vector2(judgement_size);
@@ -49,11 +49,11 @@ namespace osu.Game.Rulesets.Judgements
        {
            this.colours = colours;

-            Child = new SkinnableDrawable($"Play/{Judgement.Result}", _ => JudgementText = new OsuSpriteText
+            Child = new SkinnableDrawable($"Play/{Result.Type}", _ => JudgementText = new OsuSpriteText
            {
-                Text = Judgement.Result.GetDescription().ToUpperInvariant(),
+                Text = Result.Type.GetDescription().ToUpperInvariant(),
                Font = @"Venera",
-                Colour = judgementColour(Judgement.Result),
+                Colour = judgementColour(Result.Type),
                Scale = new Vector2(0.85f, 1),
                TextSize = 12
            }, restrictSize: false);
@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Judgements

            this.FadeInFromZero(100, Easing.OutQuint);

-            switch (Judgement.Result)
+            switch (Result.Type)
            {
                case HitResult.None:
                    break;
@@ -1,74 +1,48 @@
 // Copyright (c) 2007-2018 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;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;

 namespace osu.Game.Rulesets.Judgements
 {
+    /// <summary>
+    /// The scoring information provided by a <see cref="HitObject"/>.
+    /// </summary>
    public class Judgement
    {
-        /// <summary>
-        /// Whether this judgement is the result of a hit or a miss.
-        /// </summary>
-        public HitResult Result;
-
        /// <summary>
        /// The maximum <see cref="HitResult"/> that can be achieved.
        /// </summary>
        public virtual HitResult MaxResult => HitResult.Perfect;

        /// <summary>
-        /// The combo prior to this judgement occurring.
-        /// </summary>
-        public int ComboAtJudgement;
-
-        /// <summary>
-        /// The highest combo achieved prior to this judgement occurring.
-        /// </summary>
-        public 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"/>.
-        /// </summary>
-        public double TimeOffset { get; set; }
-
-        /// <summary>
-        /// Whether the <see cref="Result"/> should affect the current combo.
+        /// Whether this <see cref="Judgement"/> should affect the current combo.
        /// </summary>
        public virtual bool AffectsCombo => true;

        /// <summary>
-        /// Whether the <see cref="Result"/> should be counted as base (combo) or bonus score.
+        /// Whether this <see cref="Judgement"/> should be counted as base (combo) or bonus score.
        /// </summary>
        public virtual bool IsBonus => !AffectsCombo;

        /// <summary>
-        /// The numeric representation for the result achieved.
-        /// </summary>
-        public int NumericResult => NumericResultFor(Result);
-
-        /// <summary>
-        /// The numeric representation for the maximum achievable result.
+        /// The numeric score representation for the maximum achievable result.
        /// </summary>
        public int MaxNumericResult => NumericResultFor(MaxResult);

        /// <summary>
-        /// Convert a <see cref="HitResult"/> to a numeric score representation.
+        /// Retrieves the numeric score representation of a <see cref="HitResult"/>.
        /// </summary>
-        /// <param name="result">The value to convert.</param>
-        /// <returns>The number.</returns>
+        /// <param name="result">The <see cref="HitResult"/> to find the numeric score representation for.</param>
+        /// <returns>The numeric score representation of <paramref name="result"/>.</returns>
        protected virtual int NumericResultFor(HitResult result) => result > HitResult.Miss ? 1 : 0;
+
+        /// <summary>
+        /// Retrieves the numeric score representation of a <see cref="JudgementResult"/>.
+        /// </summary>
+        /// <param name="result">The <see cref="JudgementResult"/> to find the numeric score representation for.</param>
+        /// <returns>The numeric score representation of <paramref name="result"/>.</returns>
+        public int NumericResultFor(JudgementResult result) => NumericResultFor(result.Type);
    }
 }
--- a/Show More
+++ b/Show More