Merge branch 'master' into fix-tournament-ruleset-dropdown-anchor

.idea/.idea.osu.Desktop/.idea/modules.xml

@@ -2,7 +2,7 @@
 <project version="4">
   <component name="ProjectModuleManager">
     <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/.idea.osu.Desktop/riderModule.iml" filepath="$PROJECT_DIR$/.idea/.idea.osu.Desktop/riderModule.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/.idea.osu.Desktop/.idea/riderModule.iml" filepath="$PROJECT_DIR$/.idea/.idea.osu.Desktop/.idea/riderModule.iml" />
     </modules>
   </component>
 </project>

osu.Android.props

@@ -51,7 +51,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.904.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2020.1016.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.923.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.1009.0" />
   </ItemGroup>
 </Project>

osu.Android/OsuGameActivity.cs

@@ -9,7 +9,7 @@ using osu.Framework.Android;
 
 namespace osu.Android
 {
-    [Activity(Theme = "@android:style/Theme.NoTitleBar", MainLauncher = true, ScreenOrientation = ScreenOrientation.FullSensor, SupportsPictureInPicture = false, ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.ScreenSize, HardwareAccelerated = false)]
+    [Activity(Theme = "@android:style/Theme.NoTitleBar", MainLauncher = true, ScreenOrientation = ScreenOrientation.FullUser, SupportsPictureInPicture = false, ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.ScreenSize, HardwareAccelerated = false)]
     public class OsuGameActivity : AndroidGameActivity
     {
         protected override Framework.Game CreateGame() => new OsuGameAndroid();

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -29,6 +29,11 @@ namespace osu.Desktop.Updater
 
         private static readonly Logger logger = Logger.GetLogger("updater");
 
+        /// <summary>
+        /// Whether an update has been downloaded but not yet applied.
+        /// </summary>
+        private bool updatePending;
+
         [BackgroundDependencyLoader]
         private void load(NotificationOverlay notification)
         {
@@ -37,9 +42,9 @@ namespace osu.Desktop.Updater
             Splat.Locator.CurrentMutable.Register(() => new SquirrelLogger(), typeof(Splat.ILogger));
         }
 
-        protected override async Task PerformUpdateCheck() => await checkForUpdateAsync();
+        protected override async Task<bool> PerformUpdateCheck() => await checkForUpdateAsync();
 
-        private async Task checkForUpdateAsync(bool useDeltaPatching = true, UpdateProgressNotification notification = null)
+        private async Task<bool> checkForUpdateAsync(bool useDeltaPatching = true, UpdateProgressNotification notification = null)
         {
             // should we schedule a retry on completion of this check?
             bool scheduleRecheck = true;
@@ -49,9 +54,19 @@ namespace osu.Desktop.Updater
                 updateManager ??= await UpdateManager.GitHubUpdateManager(@"https://github.com/ppy/osu", @"osulazer", null, null, true);
 
                 var info = await updateManager.CheckForUpdate(!useDeltaPatching);
+
                 if (info.ReleasesToApply.Count == 0)
+                {
+                    if (updatePending)
+                    {
+                        // the user may have dismissed the completion notice, so show it again.
+                        notificationOverlay.Post(new UpdateCompleteNotification(this));
+                        return true;
+                    }
+
                     // no updates available. bail and retry later.
-                    return;
+                    return false;
+                }
 
                 if (notification == null)
                 {
@@ -72,6 +87,7 @@ namespace osu.Desktop.Updater
                     await updateManager.ApplyReleases(info, p => notification.Progress = p / 100f);
 
                     notification.State = ProgressNotificationState.Completed;
+                    updatePending = true;
                 }
                 catch (Exception e)
                 {
@@ -103,6 +119,8 @@ namespace osu.Desktop.Updater
                     Scheduler.AddDelayed(async () => await checkForUpdateAsync(), 60000 * 30);
                 }
             }
+
+            return true;
         }
 
         protected override void Dispose(bool isDisposing)
@@ -111,10 +129,27 @@ namespace osu.Desktop.Updater
             updateManager?.Dispose();
         }
 
+        private class UpdateCompleteNotification : ProgressCompletionNotification
+        {
+            [Resolved]
+            private OsuGame game { get; set; }
+
+            public UpdateCompleteNotification(SquirrelUpdateManager updateManager)
+            {
+                Text = @"Update ready to install. Click to restart!";
+
+                Activated = () =>
+                {
+                    updateManager.PrepareUpdateAsync()
+                                 .ContinueWith(_ => updateManager.Schedule(() => game.GracefullyExit()));
+                    return true;
+                };
+            }
+        }
+
         private class UpdateProgressNotification : ProgressNotification
         {
             private readonly SquirrelUpdateManager updateManager;
-            private OsuGame game;
 
             public UpdateProgressNotification(SquirrelUpdateManager updateManager)
             {
@@ -123,23 +158,12 @@ namespace osu.Desktop.Updater
 
             protected override Notification CreateCompletionNotification()
             {
-                return new ProgressCompletionNotification
+                return new UpdateCompleteNotification(updateManager);
-                {
-                    Text = @"Update ready to install. Click to restart!",
-                    Activated = () =>
-                    {
-                        updateManager.PrepareUpdateAsync()
-                                     .ContinueWith(_ => updateManager.Schedule(() => game.GracefullyExit()));
-                        return true;
-                    }
-                };
             }
 
             [BackgroundDependencyLoader]
-            private void load(OsuColour colours, OsuGame game)
+            private void load(OsuColour colours)
             {
-                this.game = game;
-
                 IconContent.AddRange(new Drawable[]
                 {
                     new Box

osu.Desktop/Windows/GameplayWinKeyBlocker.cs

@@ -5,24 +5,24 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Platform;
+using osu.Game;
 using osu.Game.Configuration;
 
 namespace osu.Desktop.Windows
 {
     public class GameplayWinKeyBlocker : Component
     {
-        private Bindable<bool> allowScreenSuspension;
         private Bindable<bool> disableWinKey;
+        private Bindable<bool> localUserPlaying;
 
-        private GameHost host;
+        [Resolved]
+        private GameHost host { get; set; }
 
         [BackgroundDependencyLoader]
-        private void load(GameHost host, OsuConfigManager config)
+        private void load(OsuGame game, OsuConfigManager config)
         {
-            this.host = host;
+            localUserPlaying = game.LocalUserPlaying.GetBoundCopy();
-
+            localUserPlaying.BindValueChanged(_ => updateBlocking());
-            allowScreenSuspension = host.AllowScreenSuspension.GetBoundCopy();
-            allowScreenSuspension.BindValueChanged(_ => updateBlocking());
 
             disableWinKey = config.GetBindable<bool>(OsuSetting.GameplayDisableWinKey);
             disableWinKey.BindValueChanged(_ => updateBlocking(), true);
@@ -30,7 +30,7 @@ namespace osu.Desktop.Windows
 
         private void updateBlocking()
         {
-            bool shouldDisable = disableWinKey.Value && !allowScreenSuspension.Value;
+            bool shouldDisable = disableWinKey.Value && localUserPlaying.Value;
 
             if (shouldDisable)
                 host.InputThread.Scheduler.Add(WindowsKey.Disable);

osu.Game.Rulesets.Catch.Tests/Mods/TestSceneCatchModPerfect.cs

@@ -50,7 +50,7 @@ namespace osu.Game.Rulesets.Catch.Tests.Mods
         public void TestDroplet(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new Droplet { StartTime = 1000 }), shouldMiss);
 
         // We only care about testing misses, hits are tested via JuiceStream
-        [TestCase(false)]
+        [TestCase(true)]
         public void TestTinyDroplet(bool shouldMiss) => CreateHitObjectTest(new HitObjectTestData(new TinyDroplet { StartTime = 1000 }), shouldMiss);
     }
 }

osu.Game.Rulesets.Catch.Tests/TestSceneComboCounter.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Rulesets.Catch.Tests
         [Test]
         public void TestCatchComboCounter()
         {
-            AddRepeatStep("perform hit", () => performJudgement(HitResult.Perfect), 20);
+            AddRepeatStep("perform hit", () => performJudgement(HitResult.Great), 20);
             AddStep("perform miss", () => performJudgement(HitResult.Miss));
 
             AddStep("randomize judged object colour", () =>

osu.Game.Rulesets.Catch/CatchRuleset.cs

@@ -141,11 +141,40 @@ namespace osu.Game.Rulesets.Catch
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = OsuIcon.RulesetCatch };
 
+        protected override IEnumerable<HitResult> GetValidHitResults()
+        {
+            return new[]
+            {
+                HitResult.Great,
+
+                HitResult.LargeTickHit,
+                HitResult.SmallTickHit,
+                HitResult.LargeBonus,
+            };
+        }
+
+        public override string GetDisplayNameForHitResult(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.LargeTickHit:
+                    return "large droplet";
+
+                case HitResult.SmallTickHit:
+                    return "small droplet";
+
+                case HitResult.LargeBonus:
+                    return "banana";
+            }
+
+            return base.GetDisplayNameForHitResult(result);
+        }
+
         public override DifficultyCalculator CreateDifficultyCalculator(WorkingBeatmap beatmap) => new CatchDifficultyCalculator(this, beatmap);
 
         public override ISkin CreateLegacySkinProvider(ISkinSource source, IBeatmap beatmap) => new CatchLegacySkinTransformer(source);
 
-        public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new CatchPerformanceCalculator(this, beatmap, score);
+        public override PerformanceCalculator CreatePerformanceCalculator(DifficultyAttributes attributes, ScoreInfo score) => new CatchPerformanceCalculator(this, attributes, score);
 
         public int LegacyID => 2;
 

osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs

@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Extensions;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
@@ -25,8 +24,8 @@ namespace osu.Game.Rulesets.Catch.Difficulty
         private int tinyTicksMissed;
         private int misses;
 
-        public CatchPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, ScoreInfo score)
+        public CatchPerformanceCalculator(Ruleset ruleset, DifficultyAttributes attributes, ScoreInfo score)
-            : base(ruleset, beatmap, score)
+            : base(ruleset, attributes, score)
         {
         }
 
@@ -34,7 +33,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
         {
             mods = Score.Mods;
 
-            fruitsHit = Score.Statistics.GetOrDefault(HitResult.Perfect);
+            fruitsHit = Score.Statistics.GetOrDefault(HitResult.Great);
             ticksHit = Score.Statistics.GetOrDefault(HitResult.LargeTickHit);
             tinyTicksHit = Score.Statistics.GetOrDefault(HitResult.SmallTickHit);
             tinyTicksMissed = Score.Statistics.GetOrDefault(HitResult.SmallTickMiss);

osu.Game.Rulesets.Catch/Judgements/CatchBananaJudgement.cs

@@ -8,31 +8,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
 {
     public class CatchBananaJudgement : CatchJudgement
     {
-        public override bool AffectsCombo => false;
+        public override HitResult MaxResult => HitResult.LargeBonus;
-
-        protected override int NumericResultFor(HitResult result)
-        {
-            switch (result)
-            {
-                default:
-                    return 0;
-
-                case HitResult.Perfect:
-                    return 1100;
-            }
-        }
-
-        protected override double HealthIncreaseFor(HitResult result)
-        {
-            switch (result)
-            {
-                default:
-                    return 0;
-
-                case HitResult.Perfect:
-                    return DEFAULT_MAX_HEALTH_INCREASE * 0.75;
-            }
-        }
 
         public override bool ShouldExplodeFor(JudgementResult result) => true;
     }

osu.Game.Rulesets.Catch/Judgements/CatchDropletJudgement.cs

@@ -7,16 +7,6 @@ namespace osu.Game.Rulesets.Catch.Judgements
 {
     public class CatchDropletJudgement : CatchJudgement
     {
-        protected override int NumericResultFor(HitResult result)
+        public override HitResult MaxResult => HitResult.LargeTickHit;
-        {
-            switch (result)
-            {
-                default:
-                    return 0;
-
-                case HitResult.Perfect:
-                    return 30;
-            }
-        }
     }
 }

osu.Game.Rulesets.Catch/Judgements/CatchJudgement.cs

@@ -9,19 +9,7 @@ namespace osu.Game.Rulesets.Catch.Judgements
 {
     public class CatchJudgement : Judgement
     {
-        public override HitResult MaxResult => HitResult.Perfect;
+        public override HitResult MaxResult => HitResult.Great;
-
-        protected override int NumericResultFor(HitResult result)
-        {
-            switch (result)
-            {
-                default:
-                    return 0;
-
-                case HitResult.Perfect:
-                    return 300;
-            }
-        }
 
         /// <summary>
         /// Whether fruit on the platter should explode or drop.

osu.Game.Rulesets.Catch/Judgements/CatchTinyDropletJudgement.cs

@@ -7,30 +7,6 @@ namespace osu.Game.Rulesets.Catch.Judgements
 {
     public class CatchTinyDropletJudgement : CatchJudgement
     {
-        public override bool AffectsCombo => false;
+        public override HitResult MaxResult => HitResult.SmallTickHit;
-
-        protected override int NumericResultFor(HitResult result)
-        {
-            switch (result)
-            {
-                default:
-                    return 0;
-
-                case HitResult.Perfect:
-                    return 10;
-            }
-        }
-
-        protected override double HealthIncreaseFor(HitResult result)
-        {
-            switch (result)
-            {
-                default:
-                    return 0;
-
-                case HitResult.Perfect:
-                    return 0.02;
-            }
-        }
     }
 }

osu.Game.Rulesets.Catch/Objects/Drawables/DrawableCatchHitObject.cs

@@ -8,7 +8,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.Catch.UI;
 using osuTK;
 using osuTK.Graphics;
@@ -86,7 +85,7 @@ namespace osu.Game.Rulesets.Catch.Objects.Drawables
             if (CheckPosition == null) return;
 
             if (timeOffset >= 0 && Result != null)
-                ApplyResult(r => r.Type = CheckPosition.Invoke(HitObject) ? HitResult.Perfect : HitResult.Miss);
+                ApplyResult(r => r.Type = CheckPosition.Invoke(HitObject) ? r.Judgement.MaxResult : r.Judgement.MinResult);
         }
 
         protected override void UpdateStateTransforms(ArmedState state)

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -56,6 +57,7 @@ namespace osu.Game.Rulesets.Catch.Objects
                 Volume = s.Volume
             }).ToList();
 
+            int nodeIndex = 0;
             SliderEventDescriptor? lastEvent = null;
 
             foreach (var e in SliderEventGenerator.Generate(StartTime, SpanDuration, Velocity, TickDistance, Path.Distance, this.SpanCount(), LegacyLastTickOffset, cancellationToken))
@@ -105,7 +107,7 @@ namespace osu.Game.Rulesets.Catch.Objects
                     case SliderEventType.Repeat:
                         AddNested(new Fruit
                         {
-                            Samples = Samples,
+                            Samples = this.GetNodeSamples(nodeIndex++),
                             StartTime = e.Time,
                             X = X + Path.PositionAt(e.PathProgress).X,
                         });
@@ -119,7 +121,7 @@ namespace osu.Game.Rulesets.Catch.Objects
         public double Duration
         {
             get => this.SpanCount() * Path.Distance / Velocity;
-            set => throw new System.NotSupportedException($"Adjust via {nameof(RepeatCount)} instead"); // can be implemented if/when needed.
+            set => throw new NotSupportedException($"Adjust via {nameof(RepeatCount)} instead"); // can be implemented if/when needed.
         }
 
         public double EndTime => StartTime + Duration;

osu.Game.Rulesets.Catch/Replays/CatchAutoGenerator.cs

@@ -31,6 +31,9 @@ namespace osu.Game.Rulesets.Catch.Replays
 
         public override Replay Generate()
         {
+            if (Beatmap.HitObjects.Count == 0)
+                return Replay;
+
             // todo: add support for HT DT
             const double dash_speed = Catcher.BASE_SPEED;
             const double movement_speed = dash_speed / 2;

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

@@ -11,7 +11,7 @@ namespace osu.Game.Rulesets.Catch.Scoring
         {
             switch (result)
             {
-                case HitResult.Perfect:
+                case HitResult.Great:
                 case HitResult.Miss:
                     return true;
             }

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

@@ -7,6 +7,5 @@ namespace osu.Game.Rulesets.Catch.Scoring
 {
     public class CatchScoreProcessor : ScoreProcessor
     {
-        public override HitWindows CreateHitWindows() => new CatchHitWindows();
     }
 }

osu.Game.Rulesets.Catch/Skinning/CatchLegacySkinTransformer.cs

@@ -13,6 +13,11 @@ namespace osu.Game.Rulesets.Catch.Skinning
 {
     public class CatchLegacySkinTransformer : LegacySkinTransformer
     {
+        /// <summary>
+        /// For simplicity, let's use legacy combo font texture existence as a way to identify legacy skins from default.
+        /// </summary>
+        private bool providesComboCounter => this.HasFont(GetConfig<LegacySetting, string>(LegacySetting.ComboPrefix)?.Value ?? "score");
+
         public CatchLegacySkinTransformer(ISkinSource source)
             : base(source)
         {
@@ -20,6 +25,16 @@ namespace osu.Game.Rulesets.Catch.Skinning
 
         public override Drawable GetDrawableComponent(ISkinComponent component)
         {
+            if (component is HUDSkinComponent hudComponent)
+            {
+                switch (hudComponent.Component)
+                {
+                    case HUDSkinComponents.ComboCounter:
+                        // catch may provide its own combo counter; hide the default.
+                        return providesComboCounter ? Drawable.Empty() : null;
+                }
+            }
+
             if (!(component is CatchSkinComponent catchSkinComponent))
                 return null;
 
@@ -55,11 +70,9 @@ namespace osu.Game.Rulesets.Catch.Skinning
                            this.GetAnimation("fruit-ryuuta", true, true, true);
 
                 case CatchSkinComponents.CatchComboCounter:
-                    var comboFont = GetConfig<LegacySetting, string>(LegacySetting.ComboPrefix)?.Value ?? "score";
 
-                    // For simplicity, let's use legacy combo font texture existence as a way to identify legacy skins from default.
+                    if (providesComboCounter)
-                    if (this.HasFont(comboFont))
+                        return new LegacyCatchComboCounter(Source);
-                        return new LegacyComboCounter(Source);
 
                     break;
             }

osu.Game.Rulesets.Catch/Skinning/LegacyCatchComboCounter.cs

@@ -14,13 +14,13 @@ namespace osu.Game.Rulesets.Catch.Skinning
     /// <summary>
     /// A combo counter implementation that visually behaves almost similar to stable's osu!catch combo counter.
     /// </summary>
-    public class LegacyComboCounter : CompositeDrawable, ICatchComboCounter
+    public class LegacyCatchComboCounter : CompositeDrawable, ICatchComboCounter
     {
         private readonly LegacyRollingCounter counter;
 
         private readonly LegacyRollingCounter explosion;
 
-        public LegacyComboCounter(ISkin skin)
+        public LegacyCatchComboCounter(ISkin skin)
         {
             var fontName = skin.GetConfig<LegacySetting, string>(LegacySetting.ComboPrefix)?.Value ?? "score";
             var fontOverlap = skin.GetConfig<LegacySetting, float>(LegacySetting.ComboOverlap)?.Value ?? -2f;

osu.Game.Rulesets.Catch/UI/CatchComboDisplay.cs

@@ -33,10 +33,10 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public void OnNewResult(DrawableCatchHitObject judgedObject, JudgementResult result)
         {
-            if (!result.Judgement.AffectsCombo || !result.HasResult)
+            if (!result.Type.AffectsCombo() || !result.HasResult)
                 return;
 
-            if (result.Type == HitResult.Miss)
+            if (!result.IsHit)
             {
                 updateCombo(0, null);
                 return;
@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public void OnRevertResult(DrawableCatchHitObject judgedObject, JudgementResult result)
         {
-            if (!result.Judgement.AffectsCombo || !result.HasResult)
+            if (!result.Type.AffectsCombo() || !result.HasResult)
                 return;
 
             updateCombo(result.ComboAtJudgement, judgedObject.AccentColour.Value);

osu.Game.Rulesets.Catch/UI/CatcherArea.cs

@@ -11,6 +11,7 @@ using osu.Game.Rulesets.Catch.Objects.Drawables;
 using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osuTK;
 
@@ -52,7 +53,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public void OnNewResult(DrawableCatchHitObject fruit, JudgementResult result)
         {
-            if (result.Judgement is IgnoreJudgement)
+            if (!result.Type.IsScorable())
                 return;
 
             void runAfterLoaded(Action action)

osu.Game.Rulesets.Mania.Tests/Editor/ManiaPlacementBlueprintTestScene.cs

@@ -16,7 +16,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public abstract class ManiaPlacementBlueprintTestScene : PlacementBlueprintTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/ManiaSelectionBlueprintTestScene.cs

@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Tests.Visual;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public abstract class ManiaSelectionBlueprintTestScene : SelectionBlueprintTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneEditor.cs

@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     [TestFixture]
     public class TestSceneEditor : EditorTestScene

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneHoldNotePlacementBlueprint.cs

@@ -8,7 +8,7 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneHoldNotePlacementBlueprint : ManiaPlacementBlueprintTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneHoldNoteSelectionBlueprint.cs

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneHoldNoteSelectionBlueprint : ManiaSelectionBlueprintTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaBeatSnapGrid.cs

@@ -20,7 +20,7 @@ using osu.Game.Screens.Edit;
 using osu.Game.Tests.Visual;
 using osuTK;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneManiaBeatSnapGrid : EditorClockTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaHitObjectComposer.cs

@@ -23,7 +23,7 @@ using osu.Game.Tests.Visual;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneManiaHitObjectComposer : EditorClockTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNotePlacementBlueprint.cs

@@ -18,7 +18,7 @@ using osu.Game.Tests.Visual;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneNotePlacementBlueprint : ManiaPlacementBlueprintTestScene
     {

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneNoteSelectionBlueprint.cs

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
 using osuTK;
 
-namespace osu.Game.Rulesets.Mania.Tests
+namespace osu.Game.Rulesets.Mania.Tests.Editor
 {
     public class TestSceneNoteSelectionBlueprint : ManiaSelectionBlueprintTestScene
     {

osu.Game.Rulesets.Mania.Tests/ManiaBeatmapConversionTest.cs

@@ -83,11 +83,17 @@ namespace osu.Game.Rulesets.Mania.Tests
             RandomZ = snapshot.RandomZ;
         }
 
+        public override void PostProcess()
+        {
+            base.PostProcess();
+            Objects.Sort();
+        }
+
         public bool Equals(ManiaConvertMapping other) => other != null && RandomW == other.RandomW && RandomX == other.RandomX && RandomY == other.RandomY && RandomZ == other.RandomZ;
         public override bool Equals(ConvertMapping<ConvertValue> other) => base.Equals(other) && Equals(other as ManiaConvertMapping);
     }
 
-    public struct ConvertValue : IEquatable<ConvertValue>
+    public struct ConvertValue : IEquatable<ConvertValue>, IComparable<ConvertValue>
     {
         /// <summary>
         /// A sane value to account for osu!stable using ints everwhere.
@@ -102,5 +108,15 @@ namespace osu.Game.Rulesets.Mania.Tests
             => Precision.AlmostEquals(StartTime, other.StartTime, conversion_lenience)
                && Precision.AlmostEquals(EndTime, other.EndTime, conversion_lenience)
                && Column == other.Column;
+
+        public int CompareTo(ConvertValue other)
+        {
+            var result = StartTime.CompareTo(other.StartTime);
+
+            if (result != 0)
+                return result;
+
+            return Column.CompareTo(other.Column);
+        }
     }
 }

osu.Game.Rulesets.Mania.Tests/ManiaDifficultyCalculatorTest.cs

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Mania.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Mania";
 
-        [TestCase(2.3683365342338796d, "diffcalc-test")]
+        [TestCase(2.3449735700206298d, "diffcalc-test")]
         public void Test(double expected, string name)
             => base.Test(expected, name);
 

osu.Game.Rulesets.Mania.Tests/Skinning/TestSceneHoldNote.cs

@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Linq;
+using NUnit.Framework;
 using osu.Framework.Bindables;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
@@ -13,7 +14,8 @@ namespace osu.Game.Rulesets.Mania.Tests.Skinning
 {
     public class TestSceneHoldNote : ManiaHitObjectTestScene
     {
-        public TestSceneHoldNote()
+        [Test]
+        public void TestHoldNote()
         {
             AddToggleStep("toggle hitting", v =>
             {

osu.Game.Rulesets.Mania.Tests/TestSceneHoldNoteInput.cs

@@ -45,9 +45,9 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
-            assertTickJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Miss);
-            assertNoteJudgement(HitResult.Perfect);
+            assertNoteJudgement(HitResult.IgnoreHit);
         }
 
         /// <summary>
@@ -64,7 +64,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
-            assertTickJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Miss);
         }
 
@@ -82,7 +82,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
-            assertTickJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Miss);
         }
 
@@ -102,7 +102,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
-            assertTickJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Miss);
         }
 
@@ -122,7 +122,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
-            assertTickJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Perfect);
         }
 
@@ -141,7 +141,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
-            assertTickJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Miss);
         }
 
@@ -161,7 +161,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
-            assertTickJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Miss);
         }
 
@@ -181,7 +181,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Perfect);
-            assertTickJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Meh);
         }
 
@@ -199,7 +199,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
-            assertTickJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Miss);
         }
 
@@ -217,7 +217,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
-            assertTickJudgement(HitResult.Perfect);
+            assertTickJudgement(HitResult.LargeTickHit);
             assertTailJudgement(HitResult.Meh);
         }
 
@@ -235,7 +235,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             });
 
             assertHeadJudgement(HitResult.Miss);
-            assertTickJudgement(HitResult.Miss);
+            assertTickJudgement(HitResult.LargeTickMiss);
             assertTailJudgement(HitResult.Meh);
         }
 
@@ -280,10 +280,10 @@ namespace osu.Game.Rulesets.Mania.Tests
             }, beatmap);
 
             AddAssert("first hold note missed", () => judgementResults.Where(j => beatmap.HitObjects[0].NestedHitObjects.Contains(j.HitObject))
-                                                                      .All(j => j.Type == HitResult.Miss));
+                                                                      .All(j => !j.Type.IsHit()));
 
             AddAssert("second hold note missed", () => judgementResults.Where(j => beatmap.HitObjects[1].NestedHitObjects.Contains(j.HitObject))
-                                                                       .All(j => j.Type == HitResult.Perfect));
+                                                                       .All(j => j.Type.IsHit()));
         }
 
         private void assertHeadJudgement(HitResult result)

osu.Game.Rulesets.Mania.Tests/TestSceneNotes.cs

@@ -28,25 +28,33 @@ namespace osu.Game.Rulesets.Mania.Tests
     [TestFixture]
     public class TestSceneNotes : OsuTestScene
     {
-        [BackgroundDependencyLoader]
+        [Test]
-        private void load()
+        public void TestVariousNotes()
         {
-            Child = new FillFlowContainer
+            DrawableNote note1 = null;
+            DrawableNote note2 = null;
+            DrawableHoldNote holdNote1 = null;
+            DrawableHoldNote holdNote2 = null;
+
+            AddStep("create notes", () =>
             {
-                Clock = new FramedClock(new ManualClock()),
+                Child = new FillFlowContainer
-                Anchor = Anchor.Centre,
-                Origin = Anchor.Centre,
-                AutoSizeAxes = Axes.Both,
-                Direction = FillDirection.Horizontal,
-                Spacing = new Vector2(20),
-                Children = new[]
                 {
-                    createNoteDisplay(ScrollingDirection.Down, 1, out var note1),
+                    Clock = new FramedClock(new ManualClock()),
-                    createNoteDisplay(ScrollingDirection.Up, 2, out var note2),
+                    Anchor = Anchor.Centre,
-                    createHoldNoteDisplay(ScrollingDirection.Down, 1, out var holdNote1),
+                    Origin = Anchor.Centre,
-                    createHoldNoteDisplay(ScrollingDirection.Up, 2, out var holdNote2),
+                    AutoSizeAxes = Axes.Both,
-                }
+                    Direction = FillDirection.Horizontal,
-            };
+                    Spacing = new Vector2(20),
+                    Children = new[]
+                    {
+                        createNoteDisplay(ScrollingDirection.Down, 1, out note1),
+                        createNoteDisplay(ScrollingDirection.Up, 2, out note2),
+                        createHoldNoteDisplay(ScrollingDirection.Down, 1, out holdNote1),
+                        createHoldNoteDisplay(ScrollingDirection.Up, 2, out holdNote2),
+                    }
+                };
+            });
 
             AddAssert("note 1 facing downwards", () => verifyAnchors(note1, Anchor.y2));
             AddAssert("note 2 facing upwards", () => verifyAnchors(note2, Anchor.y0));

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmap.cs

@@ -21,13 +21,20 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         /// </summary>
         public int TotalColumns => Stages.Sum(g => g.Columns);
 
+        /// <summary>
+        /// The total number of columns that were present in this <see cref="ManiaBeatmap"/> before any user adjustments.
+        /// </summary>
+        public readonly int OriginalTotalColumns;
+
         /// <summary>
         /// Creates a new <see cref="ManiaBeatmap"/>.
         /// </summary>
         /// <param name="defaultStage">The initial stages.</param>
-        public ManiaBeatmap(StageDefinition defaultStage)
+        /// <param name="originalTotalColumns">The total number of columns present before any user adjustments. Defaults to the total columns in <paramref name="defaultStage"/>.</param>
+        public ManiaBeatmap(StageDefinition defaultStage, int? originalTotalColumns = null)
         {
             Stages.Add(defaultStage);
+            OriginalTotalColumns = originalTotalColumns ?? defaultStage.Columns;
         }
 
         public override IEnumerable<BeatmapStatistic> GetStatistics()

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

@@ -28,6 +28,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         public bool Dual;
         public readonly bool IsForCurrentRuleset;
 
+        private readonly int originalTargetColumns;
+
         // Internal for testing purposes
         internal FastRandom Random { get; private set; }
 
@@ -65,6 +67,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                 else
                     TargetColumns = Math.Max(4, Math.Min((int)roundedOverallDifficulty + 1, 7));
             }
+
+            originalTargetColumns = TargetColumns;
         }
 
         public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition);
@@ -81,7 +85,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
         protected override Beatmap<ManiaHitObject> CreateBeatmap()
         {
-            beatmap = new ManiaBeatmap(new StageDefinition { Columns = TargetColumns });
+            beatmap = new ManiaBeatmap(new StageDefinition { Columns = TargetColumns }, originalTargetColumns);
 
             if (Dual)
                 beatmap.Stages.Add(new StageDefinition { Columns = TargetColumns });
@@ -116,7 +120,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
                 prevNoteTimes.RemoveAt(0);
             prevNoteTimes.Add(newNoteTime);
 
-            density = (prevNoteTimes[^1] - prevNoteTimes[0]) / prevNoteTimes.Count;
+            if (prevNoteTimes.Count >= 2)
+                density = (prevNoteTimes[^1] - prevNoteTimes[0]) / prevNoteTimes.Count;
         }
 
         private double lastTime;
@@ -180,7 +185,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
                 case IHasDuration endTimeData:
                 {
-                    conversion = new EndTimeObjectPatternGenerator(Random, original, beatmap, originalBeatmap);
+                    conversion = new EndTimeObjectPatternGenerator(Random, original, beatmap, lastPattern, originalBeatmap);
 
                     recordNote(endTimeData.EndTime, new Vector2(256, 192));
                     computeDensity(endTimeData.EndTime);

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs

@@ -3,8 +3,8 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
-using osu.Framework.Utils;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.MathUtils;
@@ -12,6 +12,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Beatmaps.Formats;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 {
@@ -25,8 +26,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         private const float osu_base_scoring_distance = 100;
 
-        public readonly double EndTime;
+        public readonly int StartTime;
-        public readonly double SegmentDuration;
+        public readonly int EndTime;
+        public readonly int SegmentDuration;
         public readonly int SpanCount;
 
         private PatternType convertType;
@@ -41,20 +43,26 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             var distanceData = hitObject as IHasDistance;
             var repeatsData = hitObject as IHasRepeats;
 
-            SpanCount = repeatsData?.SpanCount() ?? 1;
+            Debug.Assert(distanceData != null);
 
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
             DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(hitObject.StartTime);
 
-            // The true distance, accounting for any repeats
+            double beatLength;
-            double distance = (distanceData?.Distance ?? 0) * SpanCount;
+#pragma warning disable 618
-            // The velocity of the osu! hit object - calculated as the velocity of a slider
+            if (difficultyPoint is LegacyBeatmapDecoder.LegacyDifficultyControlPoint legacyDifficultyPoint)
-            double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier / timingPoint.BeatLength;
+#pragma warning restore 618
-            // The duration of the osu! hit object
+                beatLength = timingPoint.BeatLength * legacyDifficultyPoint.BpmMultiplier;
-            double osuDuration = distance / osuVelocity;
+            else
+                beatLength = timingPoint.BeatLength / difficultyPoint.SpeedMultiplier;
 
-            EndTime = hitObject.StartTime + osuDuration;
+            SpanCount = repeatsData?.SpanCount() ?? 1;
-            SegmentDuration = (EndTime - HitObject.StartTime) / SpanCount;
+            StartTime = (int)Math.Round(hitObject.StartTime);
+
+            // This matches stable's calculation.
+            EndTime = (int)Math.Floor(StartTime + distanceData.Distance * beatLength * SpanCount * 0.01 / beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier);
+
+            SegmentDuration = (EndTime - StartTime) / SpanCount;
         }
 
         public override IEnumerable<Pattern> Generate()
@@ -76,7 +84,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             foreach (var obj in originalPattern.HitObjects)
             {
-                if (!Precision.AlmostEquals(EndTime, obj.GetEndTime()))
+                if (EndTime != (int)Math.Round(obj.GetEndTime()))
                     intermediatePattern.Add(obj);
                 else
                     endTimePattern.Add(obj);
@@ -91,35 +99,35 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             if (TotalColumns == 1)
             {
                 var pattern = new Pattern();
-                addToPattern(pattern, 0, HitObject.StartTime, EndTime);
+                addToPattern(pattern, 0, StartTime, EndTime);
                 return pattern;
             }
 
             if (SpanCount > 1)
             {
                 if (SegmentDuration <= 90)
-                    return generateRandomHoldNotes(HitObject.StartTime, 1);
+                    return generateRandomHoldNotes(StartTime, 1);
 
                 if (SegmentDuration <= 120)
                 {
                     convertType |= PatternType.ForceNotStack;
-                    return generateRandomNotes(HitObject.StartTime, SpanCount + 1);
+                    return generateRandomNotes(StartTime, SpanCount + 1);
                 }
 
                 if (SegmentDuration <= 160)
-                    return generateStair(HitObject.StartTime);
+                    return generateStair(StartTime);
 
                 if (SegmentDuration <= 200 && ConversionDifficulty > 3)
-                    return generateRandomMultipleNotes(HitObject.StartTime);
+                    return generateRandomMultipleNotes(StartTime);
 
-                double duration = EndTime - HitObject.StartTime;
+                double duration = EndTime - StartTime;
                 if (duration >= 4000)
-                    return generateNRandomNotes(HitObject.StartTime, 0.23, 0, 0);
+                    return generateNRandomNotes(StartTime, 0.23, 0, 0);
 
                 if (SegmentDuration > 400 && SpanCount < TotalColumns - 1 - RandomStart)
-                    return generateTiledHoldNotes(HitObject.StartTime);
+                    return generateTiledHoldNotes(StartTime);
 
-                return generateHoldAndNormalNotes(HitObject.StartTime);
+                return generateHoldAndNormalNotes(StartTime);
             }
 
             if (SegmentDuration <= 110)
@@ -128,37 +136,37 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     convertType |= PatternType.ForceNotStack;
                 else
                     convertType &= ~PatternType.ForceNotStack;
-                return generateRandomNotes(HitObject.StartTime, SegmentDuration < 80 ? 1 : 2);
+                return generateRandomNotes(StartTime, SegmentDuration < 80 ? 1 : 2);
             }
 
             if (ConversionDifficulty > 6.5)
             {
                 if (convertType.HasFlag(PatternType.LowProbability))
-                    return generateNRandomNotes(HitObject.StartTime, 0.78, 0.3, 0);
+                    return generateNRandomNotes(StartTime, 0.78, 0.3, 0);
 
-                return generateNRandomNotes(HitObject.StartTime, 0.85, 0.36, 0.03);
+                return generateNRandomNotes(StartTime, 0.85, 0.36, 0.03);
             }
 
             if (ConversionDifficulty > 4)
             {
                 if (convertType.HasFlag(PatternType.LowProbability))
-                    return generateNRandomNotes(HitObject.StartTime, 0.43, 0.08, 0);
+                    return generateNRandomNotes(StartTime, 0.43, 0.08, 0);
 
-                return generateNRandomNotes(HitObject.StartTime, 0.56, 0.18, 0);
+                return generateNRandomNotes(StartTime, 0.56, 0.18, 0);
             }
 
             if (ConversionDifficulty > 2.5)
             {
                 if (convertType.HasFlag(PatternType.LowProbability))
-                    return generateNRandomNotes(HitObject.StartTime, 0.3, 0, 0);
+                    return generateNRandomNotes(StartTime, 0.3, 0, 0);
 
-                return generateNRandomNotes(HitObject.StartTime, 0.37, 0.08, 0);
+                return generateNRandomNotes(StartTime, 0.37, 0.08, 0);
             }
 
             if (convertType.HasFlag(PatternType.LowProbability))
-                return generateNRandomNotes(HitObject.StartTime, 0.17, 0, 0);
+                return generateNRandomNotes(StartTime, 0.17, 0, 0);
 
-            return generateNRandomNotes(HitObject.StartTime, 0.27, 0, 0);
+            return generateNRandomNotes(StartTime, 0.27, 0, 0);
         }
 
         /// <summary>
@@ -167,7 +175,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <param name="startTime">Start time of each hold note.</param>
         /// <param name="noteCount">Number of hold notes.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateRandomHoldNotes(double startTime, int noteCount)
+        private Pattern generateRandomHoldNotes(int startTime, int noteCount)
         {
             // - - - -
             // ■ - ■ ■
@@ -202,7 +210,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <param name="startTime">The start time.</param>
         /// <param name="noteCount">The number of notes.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateRandomNotes(double startTime, int noteCount)
+        private Pattern generateRandomNotes(int startTime, int noteCount)
         {
             // - - - -
             // x - - -
@@ -234,7 +242,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         /// <param name="startTime">The start time.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateStair(double startTime)
+        private Pattern generateStair(int startTime)
         {
             // - - - -
             // x - - -
@@ -286,7 +294,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         /// <param name="startTime">The start time.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateRandomMultipleNotes(double startTime)
+        private Pattern generateRandomMultipleNotes(int startTime)
         {
             // - - - -
             // x - - -
@@ -329,7 +337,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <param name="p3">The probability required for 3 hold notes to be generated.</param>
         /// <param name="p4">The probability required for 4 hold notes to be generated.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateNRandomNotes(double startTime, double p2, double p3, double p4)
+        private Pattern generateNRandomNotes(int startTime, double p2, double p3, double p4)
         {
             // - - - -
             // ■ - ■ ■
@@ -366,7 +374,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             static bool isDoubleSample(HitSampleInfo sample) => sample.Name == HitSampleInfo.HIT_CLAP || sample.Name == HitSampleInfo.HIT_FINISH;
 
             bool canGenerateTwoNotes = !convertType.HasFlag(PatternType.LowProbability);
-            canGenerateTwoNotes &= HitObject.Samples.Any(isDoubleSample) || sampleInfoListAt(HitObject.StartTime).Any(isDoubleSample);
+            canGenerateTwoNotes &= HitObject.Samples.Any(isDoubleSample) || sampleInfoListAt(StartTime).Any(isDoubleSample);
 
             if (canGenerateTwoNotes)
                 p2 = 1;
@@ -379,7 +387,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         /// <param name="startTime">The first hold note start time.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateTiledHoldNotes(double startTime)
+        private Pattern generateTiledHoldNotes(int startTime)
         {
             // - - - -
             // ■ ■ ■ ■
@@ -394,6 +402,9 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             int columnRepeat = Math.Min(SpanCount, TotalColumns);
 
+            // Due to integer rounding, this is not guaranteed to be the same as EndTime (the class-level variable).
+            int endTime = startTime + SegmentDuration * SpanCount;
+
             int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
             if (convertType.HasFlag(PatternType.ForceNotStack) && PreviousPattern.ColumnWithObjects < TotalColumns)
                 nextColumn = FindAvailableColumn(nextColumn, PreviousPattern);
@@ -401,7 +412,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             for (int i = 0; i < columnRepeat; i++)
             {
                 nextColumn = FindAvailableColumn(nextColumn, pattern);
-                addToPattern(pattern, nextColumn, startTime, EndTime);
+                addToPattern(pattern, nextColumn, startTime, endTime);
                 startTime += SegmentDuration;
             }
 
@@ -413,7 +424,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         /// <param name="startTime">The start time of notes.</param>
         /// <returns>The <see cref="Pattern"/> containing the hit objects.</returns>
-        private Pattern generateHoldAndNormalNotes(double startTime)
+        private Pattern generateHoldAndNormalNotes(int startTime)
         {
             // - - - -
             // ■ x x -
@@ -448,7 +459,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             for (int i = 0; i <= SpanCount; i++)
             {
-                if (!(ignoreHead && startTime == HitObject.StartTime))
+                if (!(ignoreHead && startTime == StartTime))
                 {
                     for (int j = 0; j < noteCount; j++)
                     {
@@ -471,19 +482,18 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         /// <param name="time">The time to retrieve the sample info list from.</param>
         /// <returns></returns>
-        private IList<HitSampleInfo> sampleInfoListAt(double time) => nodeSamplesAt(time)?.First() ?? HitObject.Samples;
+        private IList<HitSampleInfo> sampleInfoListAt(int time) => nodeSamplesAt(time)?.First() ?? HitObject.Samples;
 
         /// <summary>
         /// Retrieves the list of node samples that occur at time greater than or equal to <paramref name="time"/>.
         /// </summary>
         /// <param name="time">The time to retrieve node samples at.</param>
-        private List<IList<HitSampleInfo>> nodeSamplesAt(double time)
+        private List<IList<HitSampleInfo>> nodeSamplesAt(int time)
         {
             if (!(HitObject is IHasPathWithRepeats curveData))
                 return null;
 
-            // mathematically speaking this should be a whole number always, but floating-point arithmetic is not so kind
+            var index = SegmentDuration == 0 ? 0 : (time - StartTime) / SegmentDuration;
-            var index = (int)Math.Round(SegmentDuration == 0 ? 0 : (time - HitObject.StartTime) / SegmentDuration, MidpointRounding.AwayFromZero);
 
             // avoid slicing the list & creating copies, if at all possible.
             return index == 0 ? curveData.NodeSamples : curveData.NodeSamples.Skip(index).ToList();
@@ -496,7 +506,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <param name="column">The column to add the note to.</param>
         /// <param name="startTime">The start time of the note.</param>
         /// <param name="endTime">The end time of the note (set to <paramref name="startTime"/> for a non-hold note).</param>
-        private void addToPattern(Pattern pattern, int column, double startTime, double endTime)
+        private void addToPattern(Pattern pattern, int column, int startTime, int endTime)
         {
             ManiaHitObject newObject;
 

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs

@@ -14,12 +14,17 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 {
     internal class EndTimeObjectPatternGenerator : PatternGenerator
     {
-        private readonly double endTime;
+        private readonly int endTime;
+        private readonly PatternType convertType;
 
-        public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, ManiaBeatmap beatmap, IBeatmap originalBeatmap)
+        public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, ManiaBeatmap beatmap, Pattern previousPattern, IBeatmap originalBeatmap)
-            : base(random, hitObject, beatmap, new Pattern(), originalBeatmap)
+            : base(random, hitObject, beatmap, previousPattern, originalBeatmap)
         {
-            endTime = (HitObject as IHasDuration)?.EndTime ?? 0;
+            endTime = (int)((HitObject as IHasDuration)?.EndTime ?? 0);
+
+            convertType = PreviousPattern.ColumnWithObjects == TotalColumns
+                ? PatternType.None
+                : PatternType.ForceNotStack;
         }
 
         public override IEnumerable<Pattern> Generate()
@@ -40,18 +45,25 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                     break;
 
                 case 8:
-                    addToPattern(pattern, FindAvailableColumn(GetRandomColumn(), PreviousPattern), generateHold);
+                    addToPattern(pattern, getRandomColumn(), generateHold);
                     break;
 
                 default:
-                    if (TotalColumns > 0)
+                    addToPattern(pattern, getRandomColumn(0), generateHold);
-                        addToPattern(pattern, GetRandomColumn(), generateHold);
                     break;
             }
 
             return pattern;
         }
 
+        private int getRandomColumn(int? lowerBound = null)
+        {
+            if ((convertType & PatternType.ForceNotStack) > 0)
+                return FindAvailableColumn(GetRandomColumn(lowerBound), lowerBound, patterns: PreviousPattern);
+
+            return FindAvailableColumn(GetRandomColumn(lowerBound), lowerBound);
+        }
+
         /// <summary>
         /// Constructs and adds a note to a pattern.
         /// </summary>

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/HitObjectPatternGenerator.cs

@@ -397,7 +397,11 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
                 case 4:
                     centreProbability = 0;
-                    p2 = Math.Min(p2 * 2, 0.2);
+
+                    // Stable requires rngValue > x, which is an inverse-probability. Lazer uses true probability (1 - x).
+                    // But multiplying this value by 2 (stable) is not the same operation as dividing it by 2 (lazer),
+                    // so it needs to be converted to from a probability and then back after the multiplication.
+                    p2 = 1 - Math.Max((1 - p2) * 2, 0.8);
                     p3 = 0;
                     break;
 
@@ -408,11 +412,20 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
                 case 6:
                     centreProbability = 0;
-                    p2 = Math.Min(p2 * 2, 0.5);
+
-                    p3 = Math.Min(p3 * 2, 0.15);
+                    // Stable requires rngValue > x, which is an inverse-probability. Lazer uses true probability (1 - x).
+                    // But multiplying this value by 2 (stable) is not the same operation as dividing it by 2 (lazer),
+                    // so it needs to be converted to from a probability and then back after the multiplication.
+                    p2 = 1 - Math.Max((1 - p2) * 2, 0.5);
+                    p3 = 1 - Math.Max((1 - p3) * 2, 0.85);
                     break;
             }
 
+            // The stable values were allowed to exceed 1, which indicate <0% probability.
+            // These values needs to be clamped otherwise GetRandomNoteCount() will throw an exception.
+            p2 = Math.Clamp(p2, 0, 1);
+            p3 = Math.Clamp(p3, 0, 1);
+
             double centreVal = Random.NextDouble();
             int noteCount = GetRandomNoteCount(p2, p3);
 

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

@@ -8,5 +8,6 @@ namespace osu.Game.Rulesets.Mania.Difficulty
     public class ManiaDifficultyAttributes : DifficultyAttributes
     {
         public double GreatHitWindow;
+        public double ScoreMultiplier;
     }
 }

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

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
@@ -10,10 +11,12 @@ using osu.Game.Rulesets.Difficulty.Skills;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
 using osu.Game.Rulesets.Mania.Difficulty.Skills;
+using osu.Game.Rulesets.Mania.MathUtils;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Scoring;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Difficulty
@@ -23,11 +26,13 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         private const double star_scaling_factor = 0.018;
 
         private readonly bool isForCurrentRuleset;
+        private readonly double originalOverallDifficulty;
 
         public ManiaDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
             isForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.Equals(ruleset.RulesetInfo);
+            originalOverallDifficulty = beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty;
         }
 
         protected override DifficultyAttributes CreateDifficultyAttributes(IBeatmap beatmap, Mod[] mods, Skill[] skills, double clockRate)
@@ -40,64 +45,33 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
             return new ManiaDifficultyAttributes
             {
-                StarRating = difficultyValue(skills) * star_scaling_factor,
+                StarRating = skills[0].DifficultyValue() * star_scaling_factor,
                 Mods = mods,
                 // Todo: This int cast is temporary to achieve 1:1 results with osu!stable, and should be removed in the future
-                GreatHitWindow = (int)(hitWindows.WindowFor(HitResult.Great)) / clockRate,
+                GreatHitWindow = (int)Math.Ceiling(getHitWindow300(mods) / clockRate),
+                ScoreMultiplier = getScoreMultiplier(beatmap, mods),
                 MaxCombo = beatmap.HitObjects.Sum(h => h is HoldNote ? 2 : 1),
                 Skills = skills
             };
         }
 
-        private double difficultyValue(Skill[] skills)
-        {
-            // Preprocess the strains to find the maximum overall + individual (aggregate) strain from each section
-            var overall = skills.OfType<Overall>().Single();
-            var aggregatePeaks = new List<double>(Enumerable.Repeat(0.0, overall.StrainPeaks.Count));
-
-            foreach (var individual in skills.OfType<Individual>())
-            {
-                for (int i = 0; i < individual.StrainPeaks.Count; i++)
-                {
-                    double aggregate = individual.StrainPeaks[i] + overall.StrainPeaks[i];
-
-                    if (aggregate > aggregatePeaks[i])
-                        aggregatePeaks[i] = aggregate;
-                }
-            }
-
-            aggregatePeaks.Sort((a, b) => b.CompareTo(a)); // Sort from highest to lowest strain.
-
-            double difficulty = 0;
-            double weight = 1;
-
-            // Difficulty is the weighted sum of the highest strains from every section.
-            foreach (double strain in aggregatePeaks)
-            {
-                difficulty += strain * weight;
-                weight *= 0.9;
-            }
-
-            return difficulty;
-        }
-
         protected override IEnumerable<DifficultyHitObject> CreateDifficultyHitObjects(IBeatmap beatmap, double clockRate)
         {
-            for (int i = 1; i < beatmap.HitObjects.Count; i++)
+            var sortedObjects = beatmap.HitObjects.ToArray();
-                yield return new ManiaDifficultyHitObject(beatmap.HitObjects[i], beatmap.HitObjects[i - 1], clockRate);
+
+            LegacySortHelper<HitObject>.Sort(sortedObjects, Comparer<HitObject>.Create((a, b) => (int)Math.Round(a.StartTime) - (int)Math.Round(b.StartTime)));
+
+            for (int i = 1; i < sortedObjects.Length; i++)
+                yield return new ManiaDifficultyHitObject(sortedObjects[i], sortedObjects[i - 1], clockRate);
         }
 
-        protected override Skill[] CreateSkills(IBeatmap beatmap)
+        // Sorting is done in CreateDifficultyHitObjects, since the full list of hitobjects is required.
+        protected override IEnumerable<DifficultyHitObject> SortObjects(IEnumerable<DifficultyHitObject> input) => input;
+
+        protected override Skill[] CreateSkills(IBeatmap beatmap) => new Skill[]
         {
-            int columnCount = ((ManiaBeatmap)beatmap).TotalColumns;
+            new Strain(((ManiaBeatmap)beatmap).TotalColumns)
-
+        };
-            var skills = new List<Skill> { new Overall(columnCount) };
-
-            for (int i = 0; i < columnCount; i++)
-                skills.Add(new Individual(i, columnCount));
-
-            return skills.ToArray();
-        }
 
         protected override Mod[] DifficultyAdjustmentMods
         {
@@ -122,12 +96,73 @@ namespace osu.Game.Rulesets.Mania.Difficulty
                     new ManiaModKey3(),
                     new ManiaModKey4(),
                     new ManiaModKey5(),
+                    new MultiMod(new ManiaModKey5(), new ManiaModDualStages()),
                     new ManiaModKey6(),
+                    new MultiMod(new ManiaModKey6(), new ManiaModDualStages()),
                     new ManiaModKey7(),
+                    new MultiMod(new ManiaModKey7(), new ManiaModDualStages()),
                     new ManiaModKey8(),
+                    new MultiMod(new ManiaModKey8(), new ManiaModDualStages()),
                     new ManiaModKey9(),
+                    new MultiMod(new ManiaModKey9(), new ManiaModDualStages()),
                 }).ToArray();
             }
         }
+
+        private int getHitWindow300(Mod[] mods)
+        {
+            if (isForCurrentRuleset)
+            {
+                double od = Math.Min(10.0, Math.Max(0, 10.0 - originalOverallDifficulty));
+                return applyModAdjustments(34 + 3 * od, mods);
+            }
+
+            if (Math.Round(originalOverallDifficulty) > 4)
+                return applyModAdjustments(34, mods);
+
+            return applyModAdjustments(47, mods);
+
+            static int applyModAdjustments(double value, Mod[] mods)
+            {
+                if (mods.Any(m => m is ManiaModHardRock))
+                    value /= 1.4;
+                else if (mods.Any(m => m is ManiaModEasy))
+                    value *= 1.4;
+
+                if (mods.Any(m => m is ManiaModDoubleTime))
+                    value *= 1.5;
+                else if (mods.Any(m => m is ManiaModHalfTime))
+                    value *= 0.75;
+
+                return (int)value;
+            }
+        }
+
+        private double getScoreMultiplier(IBeatmap beatmap, Mod[] mods)
+        {
+            double scoreMultiplier = 1;
+
+            foreach (var m in mods)
+            {
+                switch (m)
+                {
+                    case ManiaModNoFail _:
+                    case ManiaModEasy _:
+                    case ManiaModHalfTime _:
+                        scoreMultiplier *= 0.5;
+                        break;
+                }
+            }
+
+            var maniaBeatmap = (ManiaBeatmap)beatmap;
+            int diff = maniaBeatmap.TotalColumns - maniaBeatmap.OriginalTotalColumns;
+
+            if (diff > 0)
+                scoreMultiplier *= 0.9;
+            else if (diff < 0)
+                scoreMultiplier *= 0.9 + 0.04 * diff;
+
+            return scoreMultiplier;
+        }
     }
 }

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

@@ -5,7 +5,6 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Extensions;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Scoring;
@@ -29,8 +28,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty
         private int countMeh;
         private int countMiss;
 
-        public ManiaPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, ScoreInfo score)
+        public ManiaPerformanceCalculator(Ruleset ruleset, DifficultyAttributes attributes, ScoreInfo score)
-            : base(ruleset, beatmap, score)
+            : base(ruleset, attributes, score)
         {
         }
 

osu.Game.Rulesets.Mania/Difficulty/Skills/Individual.cs

@@ -1,47 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Linq;
-using osu.Game.Rulesets.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Difficulty.Skills;
-using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Objects;
-
-namespace osu.Game.Rulesets.Mania.Difficulty.Skills
-{
-    public class Individual : Skill
-    {
-        protected override double SkillMultiplier => 1;
-        protected override double StrainDecayBase => 0.125;
-
-        private readonly double[] holdEndTimes;
-
-        private readonly int column;
-
-        public Individual(int column, int columnCount)
-        {
-            this.column = column;
-
-            holdEndTimes = new double[columnCount];
-        }
-
-        protected override double StrainValueOf(DifficultyHitObject current)
-        {
-            var maniaCurrent = (ManiaDifficultyHitObject)current;
-            var endTime = maniaCurrent.BaseObject.GetEndTime();
-
-            try
-            {
-                if (maniaCurrent.BaseObject.Column != column)
-                    return 0;
-
-                // We give a slight bonus if something is held meanwhile
-                return holdEndTimes.Any(t => t > endTime) ? 2.5 : 2;
-            }
-            finally
-            {
-                holdEndTimes[maniaCurrent.BaseObject.Column] = endTime;
-            }
-        }
-    }
-}

osu.Game.Rulesets.Mania/Difficulty/Skills/Overall.cs

@@ -1,56 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Game.Rulesets.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Difficulty.Skills;
-using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
-using osu.Game.Rulesets.Objects;
-
-namespace osu.Game.Rulesets.Mania.Difficulty.Skills
-{
-    public class Overall : Skill
-    {
-        protected override double SkillMultiplier => 1;
-        protected override double StrainDecayBase => 0.3;
-
-        private readonly double[] holdEndTimes;
-
-        private readonly int columnCount;
-
-        public Overall(int columnCount)
-        {
-            this.columnCount = columnCount;
-
-            holdEndTimes = new double[columnCount];
-        }
-
-        protected override double StrainValueOf(DifficultyHitObject current)
-        {
-            var maniaCurrent = (ManiaDifficultyHitObject)current;
-            var endTime = maniaCurrent.BaseObject.GetEndTime();
-
-            double holdFactor = 1.0; // Factor in case something else is held
-            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
-
-            for (int i = 0; i < columnCount; i++)
-            {
-                // If there is at least one other overlapping end or note, then we get an addition, buuuuuut...
-                if (current.BaseObject.StartTime < holdEndTimes[i] && endTime > holdEndTimes[i])
-                    holdAddition = 1.0;
-
-                // ... this addition only is valid if there is _no_ other note with the same ending.
-                // Releasing multiple notes at the same time is just as easy as releasing one
-                if (endTime == holdEndTimes[i])
-                    holdAddition = 0;
-
-                // We give a slight bonus if something is held meanwhile
-                if (holdEndTimes[i] > endTime)
-                    holdFactor = 1.25;
-            }
-
-            holdEndTimes[maniaCurrent.BaseObject.Column] = endTime;
-
-            return (1 + holdAddition) * holdFactor;
-        }
-    }
-}

osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs

@@ -0,0 +1,80 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Difficulty.Skills;
+using osu.Game.Rulesets.Mania.Difficulty.Preprocessing;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Rulesets.Mania.Difficulty.Skills
+{
+    public class Strain : Skill
+    {
+        private const double individual_decay_base = 0.125;
+        private const double overall_decay_base = 0.30;
+
+        protected override double SkillMultiplier => 1;
+        protected override double StrainDecayBase => 1;
+
+        private readonly double[] holdEndTimes;
+        private readonly double[] individualStrains;
+
+        private double individualStrain;
+        private double overallStrain;
+
+        public Strain(int totalColumns)
+        {
+            holdEndTimes = new double[totalColumns];
+            individualStrains = new double[totalColumns];
+            overallStrain = 1;
+        }
+
+        protected override double StrainValueOf(DifficultyHitObject current)
+        {
+            var maniaCurrent = (ManiaDifficultyHitObject)current;
+            var endTime = maniaCurrent.BaseObject.GetEndTime();
+            var column = maniaCurrent.BaseObject.Column;
+
+            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
+            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
+
+            // Fill up the holdEndTimes array
+            for (int i = 0; i < holdEndTimes.Length; ++i)
+            {
+                // If there is at least one other overlapping end or note, then we get an addition, buuuuuut...
+                if (Precision.DefinitelyBigger(holdEndTimes[i], maniaCurrent.BaseObject.StartTime, 1) && Precision.DefinitelyBigger(endTime, holdEndTimes[i], 1))
+                    holdAddition = 1.0;
+
+                // ... this addition only is valid if there is _no_ other note with the same ending. Releasing multiple notes at the same time is just as easy as releasing 1
+                if (Precision.AlmostEquals(endTime, holdEndTimes[i], 1))
+                    holdAddition = 0;
+
+                // We give a slight bonus to everything if something is held meanwhile
+                if (Precision.DefinitelyBigger(holdEndTimes[i], endTime, 1))
+                    holdFactor = 1.25;
+
+                // Decay individual strains
+                individualStrains[i] = applyDecay(individualStrains[i], current.DeltaTime, individual_decay_base);
+            }
+
+            holdEndTimes[column] = endTime;
+
+            // Increase individual strain in own column
+            individualStrains[column] += 2.0 * holdFactor;
+            individualStrain = individualStrains[column];
+
+            overallStrain = applyDecay(overallStrain, current.DeltaTime, overall_decay_base) + (1 + holdAddition) * holdFactor;
+
+            return individualStrain + overallStrain - CurrentStrain;
+        }
+
+        protected override double GetPeakStrain(double offset)
+            => applyDecay(individualStrain, offset - Previous[0].BaseObject.StartTime, individual_decay_base)
+               + applyDecay(overallStrain, offset - Previous[0].BaseObject.StartTime, overall_decay_base);
+
+        private double applyDecay(double value, double deltaTime, double decayBase)
+            => value * Math.Pow(decayBase, deltaTime / 1000);
+    }
+}

osu.Game.Rulesets.Mania/Edit/ManiaSelectionHandler.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Mania.Edit
             int minColumn = int.MaxValue;
             int maxColumn = int.MinValue;
 
-            foreach (var obj in SelectedHitObjects.OfType<ManiaHitObject>())
+            foreach (var obj in EditorBeatmap.SelectedHitObjects.OfType<ManiaHitObject>())
             {
                 if (obj.Column < minColumn)
                     minColumn = obj.Column;
@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Mania.Edit
 
             columnDelta = Math.Clamp(columnDelta, -minColumn, maniaPlayfield.TotalColumns - 1 - maxColumn);
 
-            foreach (var obj in SelectedHitObjects.OfType<ManiaHitObject>())
+            foreach (var obj in EditorBeatmap.SelectedHitObjects.OfType<ManiaHitObject>())
                 obj.Column += columnDelta;
         }
     }

osu.Game.Rulesets.Mania/Judgements/HoldNoteTickJudgement.cs

@@ -7,18 +7,6 @@ namespace osu.Game.Rulesets.Mania.Judgements
 {
     public class HoldNoteTickJudgement : ManiaJudgement
     {
-        protected override int NumericResultFor(HitResult result) => result == MaxResult ? 20 : 0;
+        public override HitResult MaxResult => HitResult.LargeTickHit;
-
-        protected override double HealthIncreaseFor(HitResult result)
-        {
-            switch (result)
-            {
-                default:
-                    return 0;
-
-                case HitResult.Perfect:
-                    return 0.01;
-            }
-        }
     }
 }

osu.Game.Rulesets.Mania/Judgements/ManiaJudgement.cs

@@ -8,27 +8,33 @@ namespace osu.Game.Rulesets.Mania.Judgements
 {
     public class ManiaJudgement : Judgement
     {
-        protected override int NumericResultFor(HitResult result)
+        protected override double HealthIncreaseFor(HitResult result)
         {
             switch (result)
             {
-                default:
+                case HitResult.LargeTickHit:
-                    return 0;
+                    return DEFAULT_MAX_HEALTH_INCREASE * 0.1;
+
+                case HitResult.LargeTickMiss:
+                    return -DEFAULT_MAX_HEALTH_INCREASE * 0.1;
 
                 case HitResult.Meh:
-                    return 50;
+                    return -DEFAULT_MAX_HEALTH_INCREASE * 0.5;
 
                 case HitResult.Ok:
-                    return 100;
+                    return -DEFAULT_MAX_HEALTH_INCREASE * 0.3;
 
                 case HitResult.Good:
-                    return 200;
+                    return DEFAULT_MAX_HEALTH_INCREASE * 0.1;
 
                 case HitResult.Great:
-                    return 300;
+                    return DEFAULT_MAX_HEALTH_INCREASE * 0.8;
 
                 case HitResult.Perfect:
-                    return 350;
+                    return DEFAULT_MAX_HEALTH_INCREASE;
+
+                default:
+                    return base.HealthIncreaseFor(result);
             }
         }
     }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override IBeatmapConverter CreateBeatmapConverter(IBeatmap beatmap) => new ManiaBeatmapConverter(beatmap, this);
 
-        public override PerformanceCalculator CreatePerformanceCalculator(WorkingBeatmap beatmap, ScoreInfo score) => new ManiaPerformanceCalculator(this, beatmap, score);
+        public override PerformanceCalculator CreatePerformanceCalculator(DifficultyAttributes attributes, ScoreInfo score) => new ManiaPerformanceCalculator(this, attributes, score);
 
         public const string SHORT_NAME = "mania";
 
@@ -319,6 +319,31 @@ namespace osu.Game.Rulesets.Mania
             return (PlayfieldType)Enum.GetValues(typeof(PlayfieldType)).Cast<int>().OrderByDescending(i => i).First(v => variant >= v);
         }
 
+        protected override IEnumerable<HitResult> GetValidHitResults()
+        {
+            return new[]
+            {
+                HitResult.Perfect,
+                HitResult.Great,
+                HitResult.Good,
+                HitResult.Ok,
+                HitResult.Meh,
+
+                HitResult.LargeTickHit,
+            };
+        }
+
+        public override string GetDisplayNameForHitResult(HitResult result)
+        {
+            switch (result)
+            {
+                case HitResult.LargeTickHit:
+                    return "hold tick";
+            }
+
+            return base.GetDisplayNameForHitResult(result);
+        }
+
         public override StatisticRow[] CreateStatisticsForScore(ScoreInfo score, IBeatmap playableBeatmap) => new[]
         {
             new StatisticRow

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

@@ -29,12 +29,12 @@ namespace osu.Game.Rulesets.Mania
                 new SettingsEnumDropdown<ManiaScrollingDirection>
                 {
                     LabelText = "Scrolling direction",
-                    Bindable = config.GetBindable<ManiaScrollingDirection>(ManiaRulesetSetting.ScrollDirection)
+                    Current = config.GetBindable<ManiaScrollingDirection>(ManiaRulesetSetting.ScrollDirection)
                 },
                 new SettingsSlider<double, TimeSlider>
                 {
                     LabelText = "Scroll speed",
-                    Bindable = config.GetBindable<double>(ManiaRulesetSetting.ScrollTime),
+                    Current = config.GetBindable<double>(ManiaRulesetSetting.ScrollTime),
                     KeyboardStep = 5
                 },
             };

osu.Game.Rulesets.Mania/MathUtils/LegacySortHelper.cs

@@ -0,0 +1,165 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+
+namespace osu.Game.Rulesets.Mania.MathUtils
+{
+    /// <summary>
+    /// Provides access to .NET4.0 unstable sorting methods.
+    /// </summary>
+    /// <remarks>
+    /// Source: https://referencesource.microsoft.com/#mscorlib/system/collections/generic/arraysorthelper.cs
+    /// Copyright (c) Microsoft Corporation.  All rights reserved.
+    /// </remarks>
+    internal static class LegacySortHelper<T>
+    {
+        private const int quick_sort_depth_threshold = 32;
+
+        public static void Sort(T[] keys, IComparer<T> comparer)
+        {
+            if (keys == null)
+                throw new ArgumentNullException(nameof(keys));
+
+            if (keys.Length == 0)
+                return;
+
+            comparer ??= Comparer<T>.Default;
+            depthLimitedQuickSort(keys, 0, keys.Length - 1, comparer, quick_sort_depth_threshold);
+        }
+
+        private static void depthLimitedQuickSort(T[] keys, int left, int right, IComparer<T> comparer, int depthLimit)
+        {
+            do
+            {
+                if (depthLimit == 0)
+                {
+                    heapsort(keys, left, right, comparer);
+                    return;
+                }
+
+                int i = left;
+                int j = right;
+
+                // pre-sort the low, middle (pivot), and high values in place.
+                // this improves performance in the face of already sorted data, or
+                // data that is made up of multiple sorted runs appended together.
+                int middle = i + ((j - i) >> 1);
+                swapIfGreater(keys, comparer, i, middle); // swap the low with the mid point
+                swapIfGreater(keys, comparer, i, j); // swap the low with the high
+                swapIfGreater(keys, comparer, middle, j); // swap the middle with the high
+
+                T x = keys[middle];
+
+                do
+                {
+                    while (comparer.Compare(keys[i], x) < 0) i++;
+                    while (comparer.Compare(x, keys[j]) < 0) j--;
+                    Contract.Assert(i >= left && j <= right, "(i>=left && j<=right)  Sort failed - Is your IComparer bogus?");
+                    if (i > j) break;
+
+                    if (i < j)
+                    {
+                        T key = keys[i];
+                        keys[i] = keys[j];
+                        keys[j] = key;
+                    }
+
+                    i++;
+                    j--;
+                } while (i <= j);
+
+                // The next iteration of the while loop is to "recursively" sort the larger half of the array and the
+                // following calls recrusively sort the smaller half.  So we subtrack one from depthLimit here so
+                // both sorts see the new value.
+                depthLimit--;
+
+                if (j - left <= right - i)
+                {
+                    if (left < j) depthLimitedQuickSort(keys, left, j, comparer, depthLimit);
+                    left = i;
+                }
+                else
+                {
+                    if (i < right) depthLimitedQuickSort(keys, i, right, comparer, depthLimit);
+                    right = j;
+                }
+            } while (left < right);
+        }
+
+        private static void heapsort(T[] keys, int lo, int hi, IComparer<T> comparer)
+        {
+            Contract.Requires(keys != null);
+            Contract.Requires(comparer != null);
+            Contract.Requires(lo >= 0);
+            Contract.Requires(hi > lo);
+            Contract.Requires(hi < keys.Length);
+
+            int n = hi - lo + 1;
+
+            for (int i = n / 2; i >= 1; i = i - 1)
+            {
+                downHeap(keys, i, n, lo, comparer);
+            }
+
+            for (int i = n; i > 1; i = i - 1)
+            {
+                swap(keys, lo, lo + i - 1);
+                downHeap(keys, 1, i - 1, lo, comparer);
+            }
+        }
+
+        private static void downHeap(T[] keys, int i, int n, int lo, IComparer<T> comparer)
+        {
+            Contract.Requires(keys != null);
+            Contract.Requires(comparer != null);
+            Contract.Requires(lo >= 0);
+            Contract.Requires(lo < keys.Length);
+
+            T d = keys[lo + i - 1];
+
+            while (i <= n / 2)
+            {
+                var child = 2 * i;
+
+                if (child < n && comparer.Compare(keys[lo + child - 1], keys[lo + child]) < 0)
+                {
+                    child++;
+                }
+
+                if (!(comparer.Compare(d, keys[lo + child - 1]) < 0))
+                    break;
+
+                keys[lo + i - 1] = keys[lo + child - 1];
+                i = child;
+            }
+
+            keys[lo + i - 1] = d;
+        }
+
+        private static void swap(T[] a, int i, int j)
+        {
+            if (i != j)
+            {
+                T t = a[i];
+                a[i] = a[j];
+                a[j] = t;
+            }
+        }
+
+        private static void swapIfGreater(T[] keys, IComparer<T> comparer, int a, int b)
+        {
+            if (a != b)
+            {
+                if (comparer.Compare(keys[a], keys[b]) > 0)
+                {
+                    T key = keys[a];
+                    keys[a] = keys[b];
+                    keys[b] = key;
+                }
+            }
+        }
+    }
+}

osu.Game.Rulesets.Mania/Mods/ManiaKeyMod.cs

@@ -39,6 +39,7 @@ namespace osu.Game.Rulesets.Mania.Mods
             typeof(ManiaModKey7),
             typeof(ManiaModKey8),
             typeof(ManiaModKey9),
+            typeof(ManiaModKey10),
         }.Except(new[] { GetType() }).ToArray();
     }
 }

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

@@ -239,11 +239,11 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         {
             if (Tail.AllJudged)
             {
-                ApplyResult(r => r.Type = HitResult.Perfect);
+                ApplyResult(r => r.Type = r.Judgement.MaxResult);
                 endHold();
             }
 
-            if (Tail.Result.Type == HitResult.Miss)
+            if (Tail.Judged && !Tail.IsHit)
                 HasBroken = true;
         }
 

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

@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (!userTriggered)
             {
                 if (!HitObject.HitWindows.CanBeHit(timeOffset))
-                    ApplyResult(r => r.Type = HitResult.Miss);
+                    ApplyResult(r => r.Type = r.Judgement.MinResult);
 
                 return;
             }

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

@@ -8,7 +8,6 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
@@ -17,6 +16,8 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
     /// </summary>
     public class DrawableHoldNoteTick : DrawableManiaHitObject<HoldNoteTick>
     {
+        public override bool DisplayResult => false;
+
         /// <summary>
         /// References the time at which the user started holding the hold note.
         /// </summary>
@@ -73,9 +74,9 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             var startTime = HoldStartTime?.Invoke();
 
             if (startTime == null || startTime > HitObject.StartTime)
-                ApplyResult(r => r.Type = HitResult.Miss);
+                ApplyResult(r => r.Type = r.Judgement.MinResult);
             else
-                ApplyResult(r => r.Type = HitResult.Perfect);
+                ApplyResult(r => r.Type = r.Judgement.MaxResult);
         }
     }
 }

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

@@ -9,7 +9,6 @@ using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {
@@ -136,7 +135,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
         /// <summary>
         /// Causes this <see cref="DrawableManiaHitObject"/> to get missed, disregarding all conditions in implementations of <see cref="DrawableHitObject.CheckForResult"/>.
         /// </summary>
-        public void MissForcefully() => ApplyResult(r => r.Type = HitResult.Miss);
+        public void MissForcefully() => ApplyResult(r => r.Type = r.Judgement.MinResult);
     }
 
     public abstract class DrawableManiaHitObject<TObject> : DrawableManiaHitObject

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

@@ -48,7 +48,7 @@ namespace osu.Game.Rulesets.Mania.Objects.Drawables
             if (!userTriggered)
             {
                 if (!HitObject.HitWindows.CanBeHit(timeOffset))
-                    ApplyResult(r => r.Type = HitResult.Miss);
+                    ApplyResult(r => r.Type = r.Judgement.MinResult);
                 return;
             }
 

osu.Game.Rulesets.Mania/Replays/ManiaAutoGenerator.cs

@@ -46,6 +46,9 @@ namespace osu.Game.Rulesets.Mania.Replays
 
         public override Replay Generate()
         {
+            if (Beatmap.HitObjects.Count == 0)
+                return Replay;
+
             var pointGroups = generateActionPoints().GroupBy(a => a.Time).OrderBy(g => g.First().Time);
 
             var actions = new List<ManiaAction>();

osu.Game.Rulesets.Mania/Resources/Testing/Beatmaps/convert-samples-expected-conversion.json

@@ -10,7 +10,7 @@
         ["soft-hitnormal"],
         ["drum-hitnormal"]
       ],
-      "Samples": ["drum-hitnormal"]
+      "Samples": ["-hitnormal"]
     }, {
       "StartTime": 1875.0,
       "EndTime": 2750.0,
@@ -19,7 +19,7 @@
         ["soft-hitnormal"],
         ["drum-hitnormal"]
       ],
-      "Samples": ["drum-hitnormal"]
+      "Samples": ["-hitnormal"]
     }]
   }, {
     "StartTime": 3750.0,

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

@@ -10,7 +10,5 @@ namespace osu.Game.Rulesets.Mania.Scoring
         protected override double DefaultAccuracyPortion => 0.95;
 
         protected override double DefaultComboPortion => 0.05;
-
-        public override HitWindows CreateHitWindows() => new ManiaHitWindows();
     }
 }

osu.Game.Rulesets.Mania/Skinning/ManiaLegacySkinTransformer.cs

@@ -130,6 +130,9 @@ namespace osu.Game.Rulesets.Mania.Skinning
 
         private Drawable getResult(HitResult result)
         {
+            if (!hitresult_mapping.ContainsKey(result))
+                return null;
+
             string filename = this.GetManiaSkinConfig<string>(hitresult_mapping[result])?.Value
                               ?? default_hitresult_skin_filenames[result];
 

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

@@ -114,7 +114,7 @@ namespace osu.Game.Rulesets.Mania.UI
             if (result.IsHit)
                 hitPolicy.HandleHit(judgedObject);
 
-            if (!result.IsHit || !judgedObject.DisplayResult || !DisplayJudgements.Value)
+            if (!result.IsHit || !DisplayJudgements.Value)
                 return;
 
             HitObjectArea.Explosions.Add(hitExplosionPool.Get(e => e.Apply(result)));

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCirclePlacementBlueprint.cs

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneHitCirclePlacementBlueprint : PlacementBlueprintTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneHitCircleSelectionBlueprint.cs

@@ -11,7 +11,7 @@ using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 using osuTK;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneHitCircleSelectionBlueprint : SelectionBlueprintTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneObjectObjectSnap.cs

@@ -0,0 +1,90 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Tests.Beatmaps;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor
+{
+    [TestFixture]
+    public class TestSceneObjectObjectSnap : TestSceneOsuEditor
+    {
+        private OsuPlayfield playfield;
+
+        protected override IBeatmap CreateBeatmap(RulesetInfo ruleset) => new TestBeatmap(Ruleset.Value, false);
+
+        public override void SetUpSteps()
+        {
+            base.SetUpSteps();
+            AddStep("get playfield", () => playfield = Editor.ChildrenOfType<OsuPlayfield>().First());
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestHitCircleSnapsToOtherHitCircle(bool distanceSnapEnabled)
+        {
+            AddStep("move mouse to centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre));
+
+            if (!distanceSnapEnabled)
+                AddStep("disable distance snap", () => InputManager.Key(Key.Q));
+
+            AddStep("enter placement mode", () => InputManager.Key(Key.Number2));
+
+            AddStep("place first object", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("move mouse slightly", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.02f, 0)));
+
+            AddStep("place second object", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("both objects at same location", () =>
+            {
+                var objects = EditorBeatmap.HitObjects;
+
+                var first = (OsuHitObject)objects.First();
+                var second = (OsuHitObject)objects.Last();
+
+                return first.Position == second.Position;
+            });
+        }
+
+        [Test]
+        public void TestHitCircleSnapsToSliderEnd()
+        {
+            AddStep("move mouse to centre", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre));
+
+            AddStep("disable distance snap", () => InputManager.Key(Key.Q));
+
+            AddStep("enter slider placement mode", () => InputManager.Key(Key.Number3));
+
+            AddStep("start slider placement", () => InputManager.Click(MouseButton.Left));
+
+            AddStep("move to place end", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.185f, 0)));
+
+            AddStep("end slider placement", () => InputManager.Click(MouseButton.Right));
+
+            AddStep("enter circle placement mode", () => InputManager.Key(Key.Number2));
+
+            AddStep("move mouse slightly", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.20f, 0)));
+
+            AddStep("place second object", () => InputManager.Click(MouseButton.Left));
+
+            AddAssert("circle is at slider's end", () =>
+            {
+                var objects = EditorBeatmap.HitObjects;
+
+                var first = (Slider)objects.First();
+                var second = (OsuHitObject)objects.Last();
+
+                return Precision.AlmostEquals(first.EndPosition, second.Position);
+            });
+        }
+    }
+}

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuDistanceSnapGrid.cs

@@ -19,7 +19,7 @@ using osu.Game.Tests.Visual;
 using osuTK;
 using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneOsuDistanceSnapGrid : OsuManualInputManagerTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditor.cs

@@ -4,10 +4,10 @@
 using NUnit.Framework;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     [TestFixture]
-    public class TestSceneEditor : EditorTestScene
+    public class TestSceneOsuEditor : EditorTestScene
     {
         protected override Ruleset CreateEditorRuleset() => new OsuRuleset();
     }

osu.Game.Rulesets.Osu.Tests/Editor/TestScenePathControlPointVisualiser.cs

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Tests.Visual;
 using osuTK;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestScenePathControlPointVisualiser : OsuTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderPlacementBlueprint.cs

@@ -14,7 +14,7 @@ using osu.Game.Tests.Visual;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneSliderPlacementBlueprint : PlacementBlueprintTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSliderSelectionBlueprint.cs

@@ -16,7 +16,7 @@ using osu.Game.Tests.Visual;
 using osuTK;
 using osuTK.Input;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneSliderSelectionBlueprint : SelectionBlueprintTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerPlacementBlueprint.cs

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneSpinnerPlacementBlueprint : PlacementBlueprintTestScene
     {

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneSpinnerSelectionBlueprint.cs

@@ -11,7 +11,7 @@ using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 using osuTK;
 
-namespace osu.Game.Rulesets.Osu.Tests
+namespace osu.Game.Rulesets.Osu.Tests.Editor
 {
     public class TestSceneSpinnerSelectionBlueprint : SelectionBlueprintTestScene
     {

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

@@ -20,7 +20,8 @@ namespace osu.Game.Rulesets.Osu.Tests
     {
         private int depthIndex;
 
-        public TestSceneHitCircle()
+        [Test]
+        public void TestVariousHitCircles()
         {
             AddStep("Miss Big Single", () => SetContents(() => testSingle(2)));
             AddStep("Miss Medium Single", () => SetContents(() => testSingle(5)));

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

@@ -40,7 +40,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 {
                     HitObjects = { new HitCircle { Position = new Vector2(256, 192) } }
                 },
-                PassCondition = () => Player.Results.Count > 0 && Player.Results[0].TimeOffset < -hitWindows.WindowFor(HitResult.Meh) && Player.Results[0].Type == HitResult.Miss
+                PassCondition = () => Player.Results.Count > 0 && Player.Results[0].TimeOffset < -hitWindows.WindowFor(HitResult.Meh) && !Player.Results[0].IsHit
             });
         }
 
@@ -59,7 +59,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 Autoplay = false,
                 Beatmap = beatmap,
-                PassCondition = () => Player.Results.Count > 0 && Player.Results[0].TimeOffset >= hitWindows.WindowFor(HitResult.Meh) && Player.Results[0].Type == HitResult.Miss
+                PassCondition = () => Player.Results.Count > 0 && Player.Results[0].TimeOffset >= hitWindows.WindowFor(HitResult.Meh) && !Player.Results[0].IsHit
             });
         }
 

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

@@ -209,9 +209,9 @@ namespace osu.Game.Rulesets.Osu.Tests
             });
 
             addJudgementAssert(hitObjects[0], HitResult.Great);
-            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.IgnoreHit);
             addJudgementAssert("slider head", () => ((Slider)hitObjects[1]).HeadCircle, HitResult.Miss);
-            addJudgementAssert("slider tick", () => ((Slider)hitObjects[1]).NestedHitObjects[1] as SliderTick, HitResult.Great);
+            addJudgementAssert("slider tick", () => ((Slider)hitObjects[1]).NestedHitObjects[1] as SliderTick, HitResult.LargeTickHit);
         }
 
         /// <summary>
@@ -252,9 +252,9 @@ namespace osu.Game.Rulesets.Osu.Tests
             });
 
             addJudgementAssert(hitObjects[0], HitResult.Great);
-            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.IgnoreHit);
             addJudgementAssert("slider head", () => ((Slider)hitObjects[1]).HeadCircle, HitResult.Great);
-            addJudgementAssert("slider tick", () => ((Slider)hitObjects[1]).NestedHitObjects[1] as SliderTick, HitResult.Great);
+            addJudgementAssert("slider tick", () => ((Slider)hitObjects[1]).NestedHitObjects[1] as SliderTick, HitResult.LargeTickHit);
         }
 
         /// <summary>
@@ -331,7 +331,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             });
 
             addJudgementAssert(hitObjects[0], HitResult.Great);
-            addJudgementAssert(hitObjects[1], HitResult.Great);
+            addJudgementAssert(hitObjects[1], HitResult.IgnoreHit);
         }
 
         private void addJudgementAssert(OsuHitObject hitObject, HitResult result)

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

@@ -27,7 +27,8 @@ namespace osu.Game.Rulesets.Osu.Tests
     {
         private int depthIndex;
 
-        public TestSceneSlider()
+        [Test]
+        public void TestVariousSliders()
         {
             AddStep("Big Single", () => SetContents(() => testSimpleBig()));
             AddStep("Medium Single", () => SetContents(() => testSimpleMedium()));
@@ -164,7 +165,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                StartTime = Time.Current + 1000,
+                StartTime = Time.Current + time_offset,
                 Position = new Vector2(239, 176),
                 Path = new SliderPath(PathType.PerfectCurve, new[]
                 {
@@ -185,22 +186,26 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private Drawable testSlowSpeed() => createSlider(speedMultiplier: 0.5);
 
-        private Drawable testShortSlowSpeed(int repeats = 0) => createSlider(distance: 100, repeats: repeats, speedMultiplier: 0.5);
+        private Drawable testShortSlowSpeed(int repeats = 0) => createSlider(distance: max_length / 4, repeats: repeats, speedMultiplier: 0.5);
 
         private Drawable testHighSpeed(int repeats = 0) => createSlider(repeats: repeats, speedMultiplier: 15);
 
-        private Drawable testShortHighSpeed(int repeats = 0) => createSlider(distance: 100, repeats: repeats, speedMultiplier: 15);
+        private Drawable testShortHighSpeed(int repeats = 0) => createSlider(distance: max_length / 4, repeats: repeats, speedMultiplier: 15);
 
-        private Drawable createSlider(float circleSize = 2, float distance = 400, int repeats = 0, double speedMultiplier = 2, int stackHeight = 0)
+        private const double time_offset = 1500;
+
+        private const float max_length = 200;
+
+        private Drawable createSlider(float circleSize = 2, float distance = max_length, int repeats = 0, double speedMultiplier = 2, int stackHeight = 0)
         {
             var slider = new Slider
             {
-                StartTime = Time.Current + 1000,
+                StartTime = Time.Current + time_offset,
-                Position = new Vector2(-(distance / 2), 0),
+                Position = new Vector2(0, -(distance / 2)),
                 Path = new SliderPath(PathType.PerfectCurve, new[]
                 {
                     Vector2.Zero,
-                    new Vector2(distance, 0),
+                    new Vector2(0, distance),
                 }, distance),
                 RepeatCount = repeats,
                 StackHeight = stackHeight
@@ -213,14 +218,14 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                StartTime = Time.Current + 1000,
+                StartTime = Time.Current + time_offset,
-                Position = new Vector2(-200, 0),
+                Position = new Vector2(-max_length / 2, 0),
                 Path = new SliderPath(PathType.PerfectCurve, new[]
                 {
                     Vector2.Zero,
-                    new Vector2(200, 200),
+                    new Vector2(max_length / 2, max_length / 2),
-                    new Vector2(400, 0)
+                    new Vector2(max_length, 0)
-                }, 600),
+                }, max_length * 1.5f),
                 RepeatCount = repeats,
             };
 
@@ -233,16 +238,16 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                StartTime = Time.Current + 1000,
+                StartTime = Time.Current + time_offset,
-                Position = new Vector2(-200, 0),
+                Position = new Vector2(-max_length / 2, 0),
                 Path = new SliderPath(PathType.Linear, new[]
                 {
                     Vector2.Zero,
-                    new Vector2(150, 75),
+                    new Vector2(max_length * 0.375f, max_length * 0.18f),
-                    new Vector2(200, 0),
+                    new Vector2(max_length / 2, 0),
-                    new Vector2(300, -200),
+                    new Vector2(max_length * 0.75f, -max_length / 2),
-                    new Vector2(400, 0),
+                    new Vector2(max_length * 0.95f, 0),
-                    new Vector2(430, 0)
+                    new Vector2(max_length, 0)
                 }),
                 RepeatCount = repeats,
             };
@@ -256,15 +261,15 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                StartTime = Time.Current + 1000,
+                StartTime = Time.Current + time_offset,
-                Position = new Vector2(-200, 0),
+                Position = new Vector2(-max_length / 2, 0),
                 Path = new SliderPath(PathType.Bezier, new[]
                 {
                     Vector2.Zero,
-                    new Vector2(150, 75),
+                    new Vector2(max_length * 0.375f, max_length * 0.18f),
-                    new Vector2(200, 100),
+                    new Vector2(max_length / 2, max_length / 4),
-                    new Vector2(300, -200),
+                    new Vector2(max_length * 0.75f, -max_length / 2),
-                    new Vector2(430, 0)
+                    new Vector2(max_length, 0)
                 }),
                 RepeatCount = repeats,
             };
@@ -278,16 +283,16 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                StartTime = Time.Current + 1000,
+                StartTime = Time.Current + time_offset,
                 Position = new Vector2(0, 0),
                 Path = new SliderPath(PathType.Linear, new[]
                 {
                     Vector2.Zero,
-                    new Vector2(-200, 0),
+                    new Vector2(-max_length / 2, 0),
                     new Vector2(0, 0),
-                    new Vector2(0, -200),
+                    new Vector2(0, -max_length / 2),
-                    new Vector2(-200, -200),
+                    new Vector2(-max_length / 2, -max_length / 2),
-                    new Vector2(0, -200)
+                    new Vector2(0, -max_length / 2)
                 }),
                 RepeatCount = repeats,
             };
@@ -305,14 +310,14 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             var slider = new Slider
             {
-                StartTime = Time.Current + 1000,
+                StartTime = Time.Current + time_offset,
-                Position = new Vector2(-100, 0),
+                Position = new Vector2(-max_length / 4, 0),
                 Path = new SliderPath(PathType.Catmull, new[]
                 {
                     Vector2.Zero,
-                    new Vector2(50, -50),
+                    new Vector2(max_length * 0.125f, max_length * 0.125f),
-                    new Vector2(150, 50),
+                    new Vector2(max_length * 0.375f, max_length * 0.125f),
-                    new Vector2(200, 0)
+                    new Vector2(max_length / 2, 0)
                 }),
                 RepeatCount = repeats,
                 NodeSamples = repeatSamples

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

@@ -73,7 +73,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.RightButton }, Time = time_during_slide_2 },
             });
 
-            AddAssert("Tracking retained", assertGreatJudge);
+            AddAssert("Tracking retained", assertMaxJudge);
         }
 
         /// <summary>
@@ -94,7 +94,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.RightButton }, Time = time_during_slide_1 },
             });
 
-            AddAssert("Tracking retained", assertGreatJudge);
+            AddAssert("Tracking retained", assertMaxJudge);
         }
 
         /// <summary>
@@ -115,7 +115,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 new OsuReplayFrame { Position = new Vector2(0, 0), Actions = { OsuAction.RightButton }, Time = time_during_slide_1 },
             });
 
-            AddAssert("Tracking retained", assertGreatJudge);
+            AddAssert("Tracking retained", assertMaxJudge);
         }
 
         /// <summary>
@@ -288,7 +288,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                 new OsuReplayFrame { Position = new Vector2(slider_path_length, OsuHitObject.OBJECT_RADIUS * 1.199f), Actions = { OsuAction.LeftButton }, Time = time_slider_end },
             });
 
-            AddAssert("Tracking kept", assertGreatJudge);
+            AddAssert("Tracking kept", assertMaxJudge);
         }
 
         /// <summary>
@@ -312,13 +312,13 @@ namespace osu.Game.Rulesets.Osu.Tests
             AddAssert("Tracking dropped", assertMidSliderJudgementFail);
         }
 
-        private bool assertGreatJudge() => judgementResults.Any() && judgementResults.All(t => t.Type == HitResult.Great);
+        private bool assertMaxJudge() => judgementResults.Any() && judgementResults.All(t => t.Type == t.Judgement.MaxResult);
 
-        private bool assertHeadMissTailTracked() => judgementResults[^2].Type == HitResult.Great && judgementResults.First().Type == HitResult.Miss;
+        private bool assertHeadMissTailTracked() => judgementResults[^2].Type == HitResult.SmallTickHit && !judgementResults.First().IsHit;
 
-        private bool assertMidSliderJudgements() => judgementResults[^2].Type == HitResult.Great;
+        private bool assertMidSliderJudgements() => judgementResults[^2].Type == HitResult.SmallTickHit;
 
-        private bool assertMidSliderJudgementFail() => judgementResults[^2].Type == HitResult.Miss;
+        private bool assertMidSliderJudgementFail() => judgementResults[^2].Type == HitResult.SmallTickMiss;
 
         private ScoreAccessibleReplayPlayer currentPlayer;
 

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

@@ -7,7 +7,6 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
-using osu.Framework.Bindables;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Testing;
 using osu.Framework.Timing;
@@ -146,7 +145,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 // multipled by 2 to nullify the score multiplier. (autoplay mod selected)
                 var totalScore = ((ScoreExposedPlayer)Player).ScoreProcessor.TotalScore.Value * 2;
-                return totalScore == (int)(drawableSpinner.RotationTracker.RateAdjustedRotation / 360) * SpinnerTick.SCORE_PER_TICK;
+                return totalScore == (int)(drawableSpinner.RotationTracker.RateAdjustedRotation / 360) * new SpinnerTick().CreateJudgement().MaxNumericResult;
             });
 
             addSeekStep(0);
@@ -194,13 +193,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             addSeekStep(0);
 
-            AddStep("adjust track rate", () => MusicController.CurrentTrack.AddAdjustment(AdjustableProperty.Tempo, new BindableDouble(rate)));
+            AddStep("adjust track rate", () => Player.GameplayClockContainer.UserPlaybackRate.Value = rate);
-            // autoplay replay frames use track time;
-            // if a spin takes 1000ms in track time and we're playing with a 2x rate adjustment, the spin will take 500ms of *real* time.
-            // therefore we need to apply the rate adjustment to the replay itself to change from track time to real time,
-            // as real time is what we care about for spinners
-            // (so we're making the spin take 1000ms in real time *always*, regardless of the track clock's rate).
-            transformReplay(replay => applyRateAdjustment(replay, rate));
 
             addSeekStep(1000);
             AddAssert("progress almost same", () => Precision.AlmostEquals(expectedProgress, drawableSpinner.Progress, 0.05));

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

@@ -11,5 +11,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         public double SpeedStrain;
         public double ApproachRate;
         public double OverallDifficulty;
+        public int HitCircleCount;
     }
 }

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

@@ -47,6 +47,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             // Add the ticks + tail of the slider. 1 is subtracted because the head circle would be counted twice (once for the slider itself in the line above)
             maxCombo += beatmap.HitObjects.OfType<Slider>().Sum(s => s.NestedHitObjects.Count - 1);
 
+            int hitCirclesCount = beatmap.HitObjects.Count(h => h is HitCircle);
+
             return new OsuDifficultyAttributes
             {
                 StarRating = starRating,
@@ -56,6 +58,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5,
                 OverallDifficulty = (80 - hitWindowGreat) / 6,
                 MaxCombo = maxCombo,
+                HitCircleCount = hitCirclesCount,
                 Skills = skills
             };
         }

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

@@ -5,11 +5,9 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Extensions;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu.Mods;
-using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 
@@ -19,26 +17,18 @@ namespace osu.Game.Rulesets.Osu.Difficulty
     {
         public new OsuDifficultyAttributes Attributes => (OsuDifficultyAttributes)base.Attributes;
 
-        private readonly int countHitCircles;
-        private readonly int beatmapMaxCombo;
-
         private Mod[] mods;
 
         private double accuracy;
         private int scoreMaxCombo;
         private int countGreat;
-        private int countGood;
+        private int countOk;
         private int countMeh;
         private int countMiss;
 
-        public OsuPerformanceCalculator(Ruleset ruleset, WorkingBeatmap beatmap, ScoreInfo score)
+        public OsuPerformanceCalculator(Ruleset ruleset, DifficultyAttributes attributes, ScoreInfo score)
-            : base(ruleset, beatmap, score)
+            : base(ruleset, attributes, score)
         {
-            countHitCircles = Beatmap.HitObjects.Count(h => h is HitCircle);
-
-            beatmapMaxCombo = Beatmap.HitObjects.Count;
-            // Add the ticks + tail of the slider. 1 is subtracted because the "headcircle" would be counted twice (once for the slider itself in the line above)
-            beatmapMaxCombo += Beatmap.HitObjects.OfType<Slider>().Sum(s => s.NestedHitObjects.Count - 1);
         }
 
         public override double Calculate(Dictionary<string, double> categoryRatings = null)
@@ -47,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             accuracy = Score.Accuracy;
             scoreMaxCombo = Score.MaxCombo;
             countGreat = Score.Statistics.GetOrDefault(HitResult.Great);
-            countGood = Score.Statistics.GetOrDefault(HitResult.Good);
+            countOk = Score.Statistics.GetOrDefault(HitResult.Ok);
             countMeh = Score.Statistics.GetOrDefault(HitResult.Meh);
             countMiss = Score.Statistics.GetOrDefault(HitResult.Miss);
 
@@ -81,7 +71,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
                 categoryRatings.Add("Accuracy", accuracyValue);
                 categoryRatings.Add("OD", Attributes.OverallDifficulty);
                 categoryRatings.Add("AR", Attributes.ApproachRate);
-                categoryRatings.Add("Max Combo", beatmapMaxCombo);
+                categoryRatings.Add("Max Combo", Attributes.MaxCombo);
             }
 
             return totalValue;
@@ -106,8 +96,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             aimValue *= Math.Pow(0.97, countMiss);
 
             // Combo scaling
-            if (beatmapMaxCombo > 0)
+            if (Attributes.MaxCombo > 0)
-                aimValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(beatmapMaxCombo, 0.8), 1.0);
+                aimValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
 
             double approachRateFactor = 1.0;
 
@@ -154,8 +144,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             speedValue *= Math.Pow(0.97, countMiss);
 
             // Combo scaling
-            if (beatmapMaxCombo > 0)
+            if (Attributes.MaxCombo > 0)
-                speedValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(beatmapMaxCombo, 0.8), 1.0);
+                speedValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
 
             double approachRateFactor = 1.0;
             if (Attributes.ApproachRate > 10.33)
@@ -178,10 +168,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
         {
             // This percentage only considers HitCircles of any value - in this part of the calculation we focus on hitting the timing hit window
             double betterAccuracyPercentage;
-            int amountHitObjectsWithAccuracy = countHitCircles;
+            int amountHitObjectsWithAccuracy = Attributes.HitCircleCount;
 
             if (amountHitObjectsWithAccuracy > 0)
-                betterAccuracyPercentage = ((countGreat - (totalHits - amountHitObjectsWithAccuracy)) * 6 + countGood * 2 + countMeh) / (double)(amountHitObjectsWithAccuracy * 6);
+                betterAccuracyPercentage = ((countGreat - (totalHits - amountHitObjectsWithAccuracy)) * 6 + countOk * 2 + countMeh) / (double)(amountHitObjectsWithAccuracy * 6);
             else
                 betterAccuracyPercentage = 0;
 
@@ -204,7 +194,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
             return accuracyValue;
         }
 
-        private int totalHits => countGreat + countGood + countMeh + countMiss;
+        private int totalHits => countGreat + countOk + countMeh + countMiss;
-        private int totalSuccessfulHits => countGreat + countGood + countMeh;
+        private int totalSuccessfulHits => countGreat + countOk + countMeh;
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCirclePlacementBlueprint.cs

@@ -21,6 +21,12 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
             InternalChild = circlePiece = new HitCirclePiece();
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            BeginPlacement();
+        }
+
         protected override void Update()
         {
             base.Update();

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/SliderBodyPiece.cs

@@ -15,6 +15,11 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
     {
         private readonly ManualSliderBody body;
 
+        /// <summary>
+        /// Offset in absolute (local) coordinates from the start of the curve.
+        /// </summary>
+        public Vector2 PathStartLocation => body.PathOffset;
+
         public SliderBodyPiece()
         {
             InternalChild = body = new ManualSliderBody
@@ -44,6 +49,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             OriginPosition = body.PathOffset;
         }
 
+        public void RecyclePath() => body.RecyclePath();
+
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => body.ReceivePositionalInputAt(screenSpacePos);
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs

@@ -24,10 +24,12 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {
     public class SliderSelectionBlueprint : OsuSelectionBlueprint<Slider>
     {
-        protected readonly SliderBodyPiece BodyPiece;
+        protected SliderBodyPiece BodyPiece { get; private set; }
-        protected readonly SliderCircleSelectionBlueprint HeadBlueprint;
+        protected SliderCircleSelectionBlueprint HeadBlueprint { get; private set; }
-        protected readonly SliderCircleSelectionBlueprint TailBlueprint;
+        protected SliderCircleSelectionBlueprint TailBlueprint { get; private set; }
-        protected readonly PathControlPointVisualiser ControlPointVisualiser;
+        protected PathControlPointVisualiser ControlPointVisualiser { get; private set; }
+
+        private readonly DrawableSlider slider;
 
         [Resolved(CanBeNull = true)]
         private HitObjectComposer composer { get; set; }
@@ -44,17 +46,17 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         public SliderSelectionBlueprint(DrawableSlider slider)
             : base(slider)
         {
-            var sliderObject = (Slider)slider.HitObject;
+            this.slider = slider;
+        }
 
+        [BackgroundDependencyLoader]
+        private void load()
+        {
             InternalChildren = new Drawable[]
             {
                 BodyPiece = new SliderBodyPiece(),
                 HeadBlueprint = CreateCircleSelectionBlueprint(slider, SliderPosition.Start),
                 TailBlueprint = CreateCircleSelectionBlueprint(slider, SliderPosition.End),
-                ControlPointVisualiser = new PathControlPointVisualiser(sliderObject, true)
-                {
-                    RemoveControlPointsRequested = removeControlPoints
-                }
             };
         }
 
@@ -66,13 +68,35 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
             pathVersion = HitObject.Path.Version.GetBoundCopy();
             pathVersion.BindValueChanged(_ => updatePath());
+
+            BodyPiece.UpdateFrom(HitObject);
         }
 
         protected override void Update()
         {
             base.Update();
 
-            BodyPiece.UpdateFrom(HitObject);
+            if (IsSelected)
+                BodyPiece.UpdateFrom(HitObject);
+        }
+
+        protected override void OnSelected()
+        {
+            AddInternal(ControlPointVisualiser = new PathControlPointVisualiser((Slider)slider.HitObject, true)
+            {
+                RemoveControlPointsRequested = removeControlPoints
+            });
+
+            base.OnSelected();
+        }
+
+        protected override void OnDeselected()
+        {
+            base.OnDeselected();
+
+            // throw away frame buffers on deselection.
+            ControlPointVisualiser?.Expire();
+            BodyPiece.RecyclePath();
         }
 
         private Vector2 rightClickPosition;
@@ -182,7 +206,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         private void updatePath()
         {
             HitObject.Path.ExpectedDistance.Value = composer?.GetSnappedDistanceFromDistance(HitObject.StartTime, (float)HitObject.Path.CalculatedDistance) ?? (float)HitObject.Path.CalculatedDistance;
-            editorBeatmap?.UpdateHitObject(HitObject);
+            editorBeatmap?.Update(HitObject);
         }
 
         public override MenuItem[] ContextMenuItems => new MenuItem[]
@@ -190,7 +214,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             new OsuMenuItem("Add control point", MenuItemType.Standard, () => addControlPoint(rightClickPosition)),
         };
 
-        public override Vector2 ScreenSpaceSelectionPoint => ((DrawableSlider)DrawableObject).HeadCircle.ScreenSpaceDrawQuad.Centre;
+        public override Vector2 ScreenSpaceSelectionPoint => BodyPiece.ToScreenSpace(BodyPiece.PathStartLocation);
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => BodyPiece.ReceivePositionalInputAt(screenSpacePos);
 

osu.Game.Rulesets.Osu/Edit/DrawableOsuEditRuleset.cs

@@ -8,6 +8,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
 using osuTK;
@@ -20,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Edit
         /// Hit objects are intentionally made to fade out at a constant slower rate than in gameplay.
         /// This allows a mapper to gain better historical context and use recent hitobjects as reference / snap points.
         /// </summary>
-        private const double editor_hit_object_fade_out_extension = 500;
+        private const double editor_hit_object_fade_out_extension = 700;
 
         public DrawableOsuEditRuleset(Ruleset ruleset, IBeatmap beatmap, IReadOnlyList<Mod> mods)
             : base(ruleset, beatmap, mods)
@@ -32,20 +33,37 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         private void updateState(DrawableHitObject hitObject, ArmedState state)
         {
-            switch (state)
+            if (state == ArmedState.Idle)
+                return;
+
+            // adjust the visuals of certain object types to make them stay on screen for longer than usual.
+            switch (hitObject)
             {
-                case ArmedState.Miss:
+                default:
-                    // Get the existing fade out transform
+                    // there are quite a few drawable hit types we don't want to extent (spinners, ticks etc.)
-                    var existing = hitObject.Transforms.LastOrDefault(t => t.TargetMember == nameof(Alpha));
+                    return;
-                    if (existing == null)
-                        return;
 
-                    hitObject.RemoveTransform(existing);
+                case DrawableSlider _:
+                    // no specifics to sliders but let them fade slower below.
+                    break;
 
-                    using (hitObject.BeginAbsoluteSequence(existing.StartTime))
+                case DrawableHitCircle circle: // also handles slider heads
-                        hitObject.FadeOut(editor_hit_object_fade_out_extension).Expire();
+                    circle.ApproachCircle
+                          .FadeOutFromOne(editor_hit_object_fade_out_extension)
+                          .Expire();
                     break;
             }
+
+            // Get the existing fade out transform
+            var existing = hitObject.Transforms.LastOrDefault(t => t.TargetMember == nameof(Alpha));
+
+            if (existing == null)
+                return;
+
+            hitObject.RemoveTransform(existing);
+
+            using (hitObject.BeginAbsoluteSequence(existing.StartTime))
+                hitObject.FadeOut(editor_hit_object_fade_out_extension).Expire();
         }
 
         protected override Playfield CreatePlayfield() => new OsuPlayfieldNoCursor();

osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs

@@ -9,7 +9,9 @@ using osu.Framework.Bindables;
 using osu.Framework.Caching;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
 using osu.Game.Beatmaps;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mods;
@@ -17,6 +19,7 @@ using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.UI;
+using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 
@@ -39,12 +42,12 @@ namespace osu.Game.Rulesets.Osu.Edit
             new SpinnerCompositionTool()
         };
 
-        private readonly BindableBool distanceSnapToggle = new BindableBool(true) { Description = "Distance Snap" };
+        private readonly Bindable<TernaryState> distanceSnapToggle = new Bindable<TernaryState>();
 
-        protected override IEnumerable<BindableBool> Toggles => new[]
+        protected override IEnumerable<TernaryButton> CreateTernaryButtons() => base.CreateTernaryButtons().Concat(new[]
         {
-            distanceSnapToggle
+            new TernaryButton(distanceSnapToggle, "Distance Snap", () => new SpriteIcon { Icon = FontAwesome.Solid.Ruler })
-        };
+        });
 
         private BindableList<HitObject> selectedHitObjects;
 
@@ -94,6 +97,10 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         public override SnapResult SnapScreenSpacePositionToValidTime(Vector2 screenSpacePosition)
         {
+            if (snapToVisibleBlueprints(screenSpacePosition, out var snapResult))
+                return snapResult;
+
+            // will be null if distance snap is disabled or not feasible for the current time value.
             if (distanceSnapGrid == null)
                 return base.SnapScreenSpacePositionToValidTime(screenSpacePosition);
 
@@ -102,13 +109,57 @@ namespace osu.Game.Rulesets.Osu.Edit
             return new SnapResult(distanceSnapGrid.ToScreenSpace(pos), time, PlayfieldAtScreenSpacePosition(screenSpacePosition));
         }
 
+        private bool snapToVisibleBlueprints(Vector2 screenSpacePosition, out SnapResult snapResult)
+        {
+            // check other on-screen objects for snapping/stacking
+            var blueprints = BlueprintContainer.SelectionBlueprints.AliveChildren;
+
+            var playfield = PlayfieldAtScreenSpacePosition(screenSpacePosition);
+
+            float snapRadius =
+                playfield.GamefieldToScreenSpace(new Vector2(OsuHitObject.OBJECT_RADIUS / 5)).X -
+                playfield.GamefieldToScreenSpace(Vector2.Zero).X;
+
+            foreach (var b in blueprints)
+            {
+                if (b.IsSelected)
+                    continue;
+
+                var hitObject = (OsuHitObject)b.HitObject;
+
+                Vector2? snap = checkSnap(hitObject.Position);
+                if (snap == null && hitObject.Position != hitObject.EndPosition)
+                    snap = checkSnap(hitObject.EndPosition);
+
+                if (snap != null)
+                {
+                    // only return distance portion, since time is not really valid
+                    snapResult = new SnapResult(snap.Value, null, playfield);
+                    return true;
+                }
+
+                Vector2? checkSnap(Vector2 checkPos)
+                {
+                    Vector2 checkScreenPos = playfield.GamefieldToScreenSpace(checkPos);
+
+                    if (Vector2.Distance(checkScreenPos, screenSpacePosition) < snapRadius)
+                        return checkScreenPos;
+
+                    return null;
+                }
+            }
+
+            snapResult = null;
+            return false;
+        }
+
         private void updateDistanceSnapGrid()
         {
             distanceSnapGridContainer.Clear();
             distanceSnapGridCache.Invalidate();
             distanceSnapGrid = null;
 
-            if (!distanceSnapToggle.Value)
+            if (distanceSnapToggle.Value != TernaryState.True)
                 return;
 
             switch (BlueprintContainer.CurrentTool)

osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs

@@ -1,7 +1,14 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Utils;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
@@ -10,40 +17,268 @@ namespace osu.Game.Rulesets.Osu.Edit
 {
     public class OsuSelectionHandler : SelectionHandler
     {
-        public override bool HandleMovement(MoveSelectionEvent moveEvent)
+        protected override void OnSelectionChanged()
         {
-            Vector2 minPosition = new Vector2(float.MaxValue, float.MaxValue);
+            base.OnSelectionChanged();
-            Vector2 maxPosition = new Vector2(float.MinValue, float.MinValue);
 
-            // Go through all hitobjects to make sure they would remain in the bounds of the editor after movement, before any movement is attempted
+            bool canOperate = EditorBeatmap.SelectedHitObjects.Count > 1 || EditorBeatmap.SelectedHitObjects.Any(s => s is Slider);
-            foreach (var h in SelectedHitObjects.OfType<OsuHitObject>())
+
+            SelectionBox.CanRotate = canOperate;
+            SelectionBox.CanScaleX = canOperate;
+            SelectionBox.CanScaleY = canOperate;
+            SelectionBox.CanReverse = canOperate;
+        }
+
+        protected override void OnOperationEnded()
+        {
+            base.OnOperationEnded();
+            referenceOrigin = null;
+        }
+
+        public override bool HandleMovement(MoveSelectionEvent moveEvent) =>
+            moveSelection(moveEvent.InstantDelta);
+
+        /// <summary>
+        /// During a transform, the initial origin is stored so it can be used throughout the operation.
+        /// </summary>
+        private Vector2? referenceOrigin;
+
+        public override bool HandleReverse()
+        {
+            var hitObjects = selectedMovableObjects;
+
+            double endTime = hitObjects.Max(h => h.GetEndTime());
+            double startTime = hitObjects.Min(h => h.StartTime);
+
+            bool moreThanOneObject = hitObjects.Length > 1;
+
+            foreach (var h in hitObjects)
             {
-                if (h is Spinner)
+                if (moreThanOneObject)
+                    h.StartTime = endTime - (h.GetEndTime() - startTime);
+
+                if (h is Slider slider)
                 {
-                    // Spinners don't support position adjustments
+                    var points = slider.Path.ControlPoints.ToArray();
-                    continue;
+                    Vector2 endPos = points.Last().Position.Value;
+
+                    slider.Path.ControlPoints.Clear();
+
+                    slider.Position += endPos;
+
+                    PathType? lastType = null;
+
+                    for (var i = 0; i < points.Length; i++)
+                    {
+                        var p = points[i];
+                        p.Position.Value -= endPos;
+
+                        // propagate types forwards to last null type
+                        if (i == points.Length - 1)
+                            p.Type.Value = lastType;
+                        else if (p.Type.Value != null)
+                        {
+                            var newType = p.Type.Value;
+                            p.Type.Value = lastType;
+                            lastType = newType;
+                        }
+
+                        slider.Path.ControlPoints.Insert(0, p);
+                    }
                 }
-
-                // Stacking is not considered
-                minPosition = Vector2.ComponentMin(minPosition, Vector2.ComponentMin(h.EndPosition + moveEvent.InstantDelta, h.Position + moveEvent.InstantDelta));
-                maxPosition = Vector2.ComponentMax(maxPosition, Vector2.ComponentMax(h.EndPosition + moveEvent.InstantDelta, h.Position + moveEvent.InstantDelta));
-            }
-
-            if (minPosition.X < 0 || minPosition.Y < 0 || maxPosition.X > DrawWidth || maxPosition.Y > DrawHeight)
-                return false;
-
-            foreach (var h in SelectedHitObjects.OfType<OsuHitObject>())
-            {
-                if (h is Spinner)
-                {
-                    // Spinners don't support position adjustments
-                    continue;
-                }
-
-                h.Position += moveEvent.InstantDelta;
             }
 
             return true;
         }
+
+        public override bool HandleFlip(Direction direction)
+        {
+            var hitObjects = selectedMovableObjects;
+
+            var selectedObjectsQuad = getSurroundingQuad(hitObjects);
+            var centre = selectedObjectsQuad.Centre;
+
+            foreach (var h in hitObjects)
+            {
+                var pos = h.Position;
+
+                switch (direction)
+                {
+                    case Direction.Horizontal:
+                        pos.X = centre.X - (pos.X - centre.X);
+                        break;
+
+                    case Direction.Vertical:
+                        pos.Y = centre.Y - (pos.Y - centre.Y);
+                        break;
+                }
+
+                h.Position = pos;
+
+                if (h is Slider slider)
+                {
+                    foreach (var point in slider.Path.ControlPoints)
+                    {
+                        point.Position.Value = new Vector2(
+                            (direction == Direction.Horizontal ? -1 : 1) * point.Position.Value.X,
+                            (direction == Direction.Vertical ? -1 : 1) * point.Position.Value.Y
+                        );
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        public override bool HandleScale(Vector2 scale, Anchor reference)
+        {
+            adjustScaleFromAnchor(ref scale, reference);
+
+            var hitObjects = selectedMovableObjects;
+
+            // for the time being, allow resizing of slider paths only if the slider is
+            // the only hit object selected. with a group selection, it's likely the user
+            // is not looking to change the duration of the slider but expand the whole pattern.
+            if (hitObjects.Length == 1 && hitObjects.First() is Slider slider)
+            {
+                Quad quad = getSurroundingQuad(slider.Path.ControlPoints.Select(p => p.Position.Value));
+                Vector2 pathRelativeDeltaScale = new Vector2(1 + scale.X / quad.Width, 1 + scale.Y / quad.Height);
+
+                foreach (var point in slider.Path.ControlPoints)
+                    point.Position.Value *= pathRelativeDeltaScale;
+            }
+            else
+            {
+                // move the selection before scaling if dragging from top or left anchors.
+                if ((reference & Anchor.x0) > 0 && !moveSelection(new Vector2(-scale.X, 0))) return false;
+                if ((reference & Anchor.y0) > 0 && !moveSelection(new Vector2(0, -scale.Y))) return false;
+
+                Quad quad = getSurroundingQuad(hitObjects);
+
+                foreach (var h in hitObjects)
+                {
+                    h.Position = new Vector2(
+                        quad.TopLeft.X + (h.X - quad.TopLeft.X) / quad.Width * (quad.Width + scale.X),
+                        quad.TopLeft.Y + (h.Y - quad.TopLeft.Y) / quad.Height * (quad.Height + scale.Y)
+                    );
+                }
+            }
+
+            return true;
+        }
+
+        private static void adjustScaleFromAnchor(ref Vector2 scale, Anchor reference)
+        {
+            // cancel out scale in axes we don't care about (based on which drag handle was used).
+            if ((reference & Anchor.x1) > 0) scale.X = 0;
+            if ((reference & Anchor.y1) > 0) scale.Y = 0;
+
+            // reverse the scale direction if dragging from top or left.
+            if ((reference & Anchor.x0) > 0) scale.X = -scale.X;
+            if ((reference & Anchor.y0) > 0) scale.Y = -scale.Y;
+        }
+
+        public override bool HandleRotation(float delta)
+        {
+            var hitObjects = selectedMovableObjects;
+
+            Quad quad = getSurroundingQuad(hitObjects);
+
+            referenceOrigin ??= quad.Centre;
+
+            foreach (var h in hitObjects)
+            {
+                h.Position = rotatePointAroundOrigin(h.Position, referenceOrigin.Value, delta);
+
+                if (h is IHasPath path)
+                {
+                    foreach (var point in path.Path.ControlPoints)
+                        point.Position.Value = rotatePointAroundOrigin(point.Position.Value, Vector2.Zero, delta);
+                }
+            }
+
+            // this isn't always the case but let's be lenient for now.
+            return true;
+        }
+
+        private bool moveSelection(Vector2 delta)
+        {
+            var hitObjects = selectedMovableObjects;
+
+            Quad quad = getSurroundingQuad(hitObjects);
+
+            if (quad.TopLeft.X + delta.X < 0 ||
+                quad.TopLeft.Y + delta.Y < 0 ||
+                quad.BottomRight.X + delta.X > DrawWidth ||
+                quad.BottomRight.Y + delta.Y > DrawHeight)
+                return false;
+
+            foreach (var h in hitObjects)
+                h.Position += delta;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Returns a gamefield-space quad surrounding the provided hit objects.
+        /// </summary>
+        /// <param name="hitObjects">The hit objects to calculate a quad for.</param>
+        private Quad getSurroundingQuad(OsuHitObject[] hitObjects) =>
+            getSurroundingQuad(hitObjects.SelectMany(h => new[] { h.Position, h.EndPosition }));
+
+        /// <summary>
+        /// Returns a gamefield-space quad surrounding the provided points.
+        /// </summary>
+        /// <param name="points">The points to calculate a quad for.</param>
+        private Quad getSurroundingQuad(IEnumerable<Vector2> points)
+        {
+            if (!EditorBeatmap.SelectedHitObjects.Any())
+                return new Quad();
+
+            Vector2 minPosition = new Vector2(float.MaxValue, float.MaxValue);
+            Vector2 maxPosition = new Vector2(float.MinValue, float.MinValue);
+
+            // Go through all hitobjects to make sure they would remain in the bounds of the editor after movement, before any movement is attempted
+            foreach (var p in points)
+            {
+                minPosition = Vector2.ComponentMin(minPosition, p);
+                maxPosition = Vector2.ComponentMax(maxPosition, p);
+            }
+
+            Vector2 size = maxPosition - minPosition;
+
+            return new Quad(minPosition.X, minPosition.Y, size.X, size.Y);
+        }
+
+        /// <summary>
+        /// All osu! hitobjects which can be moved/rotated/scaled.
+        /// </summary>
+        private OsuHitObject[] selectedMovableObjects => EditorBeatmap.SelectedHitObjects
+                                                                      .OfType<OsuHitObject>()
+                                                                      .Where(h => !(h is Spinner))
+                                                                      .ToArray();
+
+        /// <summary>
+        /// Rotate a point around an arbitrary origin.
+        /// </summary>
+        /// <param name="point">The point.</param>
+        /// <param name="origin">The centre origin to rotate around.</param>
+        /// <param name="angle">The angle to rotate (in degrees).</param>
+        private static Vector2 rotatePointAroundOrigin(Vector2 point, Vector2 origin, float angle)
+        {
+            angle = -angle;
+
+            point.X -= origin.X;
+            point.Y -= origin.Y;
+
+            Vector2 ret;
+            ret.X = point.X * MathF.Cos(MathUtils.DegreesToRadians(angle)) + point.Y * MathF.Sin(MathUtils.DegreesToRadians(angle));
+            ret.Y = point.X * -MathF.Sin(MathUtils.DegreesToRadians(angle)) + point.Y * MathF.Cos(MathUtils.DegreesToRadians(angle));
+
+            ret.X += origin.X;
+            ret.Y += origin.Y;
+
+            return ret;
+        }
     }
 }

osu.Game.Rulesets.Osu/Judgements/OsuIgnoreJudgement.cs

@@ -7,10 +7,6 @@ namespace osu.Game.Rulesets.Osu.Judgements
 {
     public class OsuIgnoreJudgement : OsuJudgement
     {
-        public override bool AffectsCombo => false;
+        public override HitResult MaxResult => HitResult.IgnoreHit;
-
-        protected override int NumericResultFor(HitResult result) => 0;
-
-        protected override double HealthIncreaseFor(HitResult result) => 0;
     }
 }

osu.Game.Rulesets.Osu/Judgements/OsuJudgement.cs

@@ -9,23 +9,5 @@ namespace osu.Game.Rulesets.Osu.Judgements
     public class OsuJudgement : Judgement
     {
         public override HitResult MaxResult => HitResult.Great;
-
-        protected override int NumericResultFor(HitResult result)
-        {
-            switch (result)
-            {
-                default:
-                    return 0;
-
-                case HitResult.Meh:
-                    return 50;
-
-                case HitResult.Good:
-                    return 100;
-
-                case HitResult.Great:
-                    return 300;
-            }
-        }
     }
 }

osu.Game.Rulesets.Osu/Mods/OsuModHidden.cs

@@ -39,7 +39,14 @@ namespace osu.Game.Rulesets.Osu.Mods
             base.ApplyToDrawableHitObjects(drawables);
         }
 
-        protected override void ApplyHiddenState(DrawableHitObject drawable, ArmedState state)
+        private double lastSliderHeadFadeOutStartTime;
+        private double lastSliderHeadFadeOutDuration;
+
+        protected override void ApplyFirstObjectIncreaseVisibilityState(DrawableHitObject drawable, ArmedState state) => applyState(drawable, true);
+
+        protected override void ApplyHiddenState(DrawableHitObject drawable, ArmedState state) => applyState(drawable, false);
+
+        private void applyState(DrawableHitObject drawable, bool increaseVisibility)
         {
             if (!(drawable is DrawableOsuHitObject d))
                 return;
@@ -54,15 +61,52 @@ namespace osu.Game.Rulesets.Osu.Mods
 
             switch (drawable)
             {
+                case DrawableSliderTail sliderTail:
+                    // use stored values from head circle to achieve same fade sequence.
+                    fadeOutDuration = lastSliderHeadFadeOutDuration;
+                    fadeOutStartTime = lastSliderHeadFadeOutStartTime;
+
+                    using (drawable.BeginAbsoluteSequence(fadeOutStartTime, true))
+                        sliderTail.FadeOut(fadeOutDuration);
+
+                    break;
+
+                case DrawableSliderRepeat sliderRepeat:
+                    // use stored values from head circle to achieve same fade sequence.
+                    fadeOutDuration = lastSliderHeadFadeOutDuration;
+                    fadeOutStartTime = lastSliderHeadFadeOutStartTime;
+
+                    using (drawable.BeginAbsoluteSequence(fadeOutStartTime, true))
+                        // only apply to circle piece – reverse arrow is not affected by hidden.
+                        sliderRepeat.CirclePiece.FadeOut(fadeOutDuration);
+
+                    break;
+
                 case DrawableHitCircle circle:
-                    // we don't want to see the approach circle
+
-                    using (circle.BeginAbsoluteSequence(h.StartTime - h.TimePreempt, true))
+                    if (circle is DrawableSliderHead)
-                        circle.ApproachCircle.Hide();
+                    {
+                        lastSliderHeadFadeOutDuration = fadeOutDuration;
+                        lastSliderHeadFadeOutStartTime = fadeOutStartTime;
+                    }
+
+                    Drawable fadeTarget = circle;
+
+                    if (increaseVisibility)
+                    {
+                        // only fade the circle piece (not the approach circle) for the increased visibility object.
+                        fadeTarget = circle.CirclePiece;
+                    }
+                    else
+                    {
+                        // we don't want to see the approach circle
+                        using (circle.BeginAbsoluteSequence(h.StartTime - h.TimePreempt, true))
+                            circle.ApproachCircle.Hide();
+                    }
 
                     // fade out immediately after fade in.
                     using (drawable.BeginAbsoluteSequence(fadeOutStartTime, true))
-                        circle.FadeOut(fadeOutDuration);
+                        fadeTarget.FadeOut(fadeOutDuration);
-
                     break;
 
                 case DrawableSlider slider:

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

@@ -125,7 +125,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (!userTriggered)
             {
                 if (!HitObject.HitWindows.CanBeHit(timeOffset))
-                    ApplyResult(r => r.Type = HitResult.Miss);
+                    ApplyResult(r => r.Type = r.Judgement.MinResult);
 
                 return;
             }
@@ -143,7 +143,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 var circleResult = (OsuHitCircleJudgementResult)r;
 
                 // Todo: This should also consider misses, but they're a little more interesting to handle, since we don't necessarily know the position at the time of a miss.
-                if (result != HitResult.Miss)
+                if (result.IsHit())
                 {
                     var localMousePosition = ToLocalSpace(inputManager.CurrentState.Mouse.Position);
                     circleResult.CursorPositionAtHit = HitObject.StackedPosition + (localMousePosition - DrawSize / 2);

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

@@ -8,7 +8,6 @@ using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Osu.Judgements;
 using osu.Game.Graphics.Containers;
 using osu.Game.Rulesets.Osu.UI;
-using osu.Game.Rulesets.Scoring;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
@@ -68,7 +67,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         /// <summary>
         /// Causes this <see cref="DrawableOsuHitObject"/> to get missed, disregarding all conditions in implementations of <see cref="DrawableHitObject.CheckForResult"/>.
         /// </summary>
-        public void MissForcefully() => ApplyResult(r => r.Type = HitResult.Miss);
+        public void MissForcefully() => ApplyResult(r => r.Type = r.Judgement.MinResult);
 
         protected override JudgementResult CreateResult(Judgement judgement) => new OsuJudgementResult(HitObject, judgement);
     }

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

@@ -8,7 +8,6 @@ using osu.Game.Configuration;
 using osuTK;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Scoring;
 using osu.Game.Skinning;
 using osuTK.Graphics;
 
@@ -67,7 +66,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             if (JudgedObject != null)
             {
                 lightingColour = JudgedObject.AccentColour.GetBoundCopy();
-                lightingColour.BindValueChanged(colour => Lighting.Colour = Result.Type == HitResult.Miss ? Color4.Transparent : colour.NewValue, true);
+                lightingColour.BindValueChanged(colour => Lighting.Colour = Result.IsHit ? colour.NewValue : Color4.Transparent, true);
             }
             else
             {

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

@@ -13,7 +13,6 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Skinning;
 using osu.Game.Rulesets.Osu.UI;
-using osu.Game.Rulesets.Scoring;
 using osuTK.Graphics;
 using osu.Game.Skinning;
 
@@ -52,6 +51,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             InternalChildren = new Drawable[]
             {
                 Body = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderBody), _ => new DefaultSliderBody(), confineMode: ConfineMode.NoScaling),
+                tailContainer = new Container<DrawableSliderTail> { RelativeSizeAxes = Axes.Both },
                 tickContainer = new Container<DrawableSliderTick> { RelativeSizeAxes = Axes.Both },
                 repeatContainer = new Container<DrawableSliderRepeat> { RelativeSizeAxes = Axes.Both },
                 Ball = new SliderBall(s, this)
@@ -63,7 +63,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                     Alpha = 0
                 },
                 headContainer = new Container<DrawableSliderHead> { RelativeSizeAxes = Axes.Both },
-                tailContainer = new Container<DrawableSliderTail> { RelativeSizeAxes = Axes.Both },
             };
         }
 
@@ -87,7 +86,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             Tracking.BindValueChanged(updateSlidingSample);
         }
 
-        private SkinnableSound slidingSample;
+        private PausableSkinnableSound slidingSample;
 
         protected override void LoadSamples()
         {
@@ -103,19 +102,22 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
                 var clone = HitObject.SampleControlPoint.ApplyTo(firstSample);
                 clone.Name = "sliderslide";
 
-                AddInternal(slidingSample = new SkinnableSound(clone)
+                AddInternal(slidingSample = new PausableSkinnableSound(clone)
                 {
                     Looping = true
                 });
             }
         }
 
+        public override void StopAllSamples()
+        {
+            base.StopAllSamples();
+            slidingSample?.Stop();
+        }
+
         private void updateSlidingSample(ValueChangedEvent<bool> tracking)
         {
-            // note that samples will not start playing if exiting a seek operation in the middle of a slider.
+            if (tracking.NewValue)
-            // may be something we want to address at a later point, but not so easy to make happen right now
-            // (SkinnableSound would need to expose whether the sample is already playing and this logic would need to run in Update).
-            if (tracking.NewValue && ShouldPlaySamples)
                 slidingSample?.Play();
             else
                 slidingSample?.Stop();
@@ -247,7 +249,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         {
             // rather than doing it this way, we should probably attach the sample to the tail circle.
             // this can only be done after we stop using LegacyLastTick.
-            if (TailCircle.Result.Type != HitResult.Miss)
+            if (TailCircle.IsHit)
                 base.PlaySamples();
         }
 

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

@@ -6,10 +6,11 @@ using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
 using osu.Framework.Utils;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using osu.Game.Rulesets.Scoring;
+using osu.Game.Skinning;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
@@ -23,6 +24,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         private readonly Drawable scaleContainer;
 
+        public readonly Drawable CirclePiece;
+
         public override bool DisplayResult => false;
 
         public DrawableSliderRepeat(SliderRepeat sliderRepeat, DrawableSlider drawableSlider)
@@ -35,7 +38,18 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
             Origin = Anchor.Centre;
 
-            InternalChild = scaleContainer = new ReverseArrowPiece();
+            InternalChild = scaleContainer = new Container
+            {
+                RelativeSizeAxes = Axes.Both,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Children = new[]
+                {
+                    // no default for this; only visible in legacy skins.
+                    CirclePiece = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderTailHitCircle), _ => Empty()),
+                    arrow = new ReverseArrowPiece(),
+                }
+            };
         }
 
         private readonly IBindable<float> scaleBindable = new BindableFloat();
@@ -50,7 +64,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (sliderRepeat.StartTime <= Time.Current)
-                ApplyResult(r => r.Type = drawableSlider.Tracking.Value ? HitResult.Great : HitResult.Miss);
+                ApplyResult(r => r.Type = drawableSlider.Tracking.Value ? r.Judgement.MaxResult : r.Judgement.MinResult);
         }
 
         protected override void UpdateInitialTransforms()
@@ -86,6 +100,8 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         private bool hasRotation;
 
+        private readonly ReverseArrowPiece arrow;
+
         public void UpdateSnakingPosition(Vector2 start, Vector2 end)
         {
             // When the repeat is hit, the arrow should fade out on spot rather than following the slider
@@ -115,18 +131,18 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
             }
 
             float aimRotation = MathUtils.RadiansToDegrees(MathF.Atan2(aimRotationVector.Y - Position.Y, aimRotationVector.X - Position.X));
-            while (Math.Abs(aimRotation - Rotation) > 180)
+            while (Math.Abs(aimRotation - arrow.Rotation) > 180)
-                aimRotation += aimRotation < Rotation ? 360 : -360;
+                aimRotation += aimRotation < arrow.Rotation ? 360 : -360;
 
             if (!hasRotation)
             {
-                Rotation = aimRotation;
+                arrow.Rotation = aimRotation;
                 hasRotation = true;
             }
             else
             {
                 // If we're already snaking, interpolate to smooth out sharp curves (linear sliders, mainly).
-                Rotation = Interpolation.ValueAt(Math.Clamp(Clock.ElapsedFrameTime, 0, 100), Rotation, aimRotation, 0, 50, Easing.OutQuint);
+                arrow.Rotation = Interpolation.ValueAt(Math.Clamp(Clock.ElapsedFrameTime, 0, 100), arrow.Rotation, aimRotation, 0, 50, Easing.OutQuint);
             }
         }
     }

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

@@ -1,16 +1,20 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Diagnostics;
+using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Scoring;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Skinning;
 using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Objects.Drawables
 {
-    public class DrawableSliderTail : DrawableOsuHitObject, IRequireTracking
+    public class DrawableSliderTail : DrawableOsuHitObject, IRequireTracking, ITrackSnaking
     {
-        private readonly Slider slider;
+        private readonly SliderTailCircle tailCircle;
 
         /// <summary>
         /// The judgement text is provided by the <see cref="DrawableSlider"/>.
@@ -19,36 +23,82 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables
 
         public bool Tracking { get; set; }
 
-        private readonly IBindable<Vector2> positionBindable = new Bindable<Vector2>();
+        private readonly IBindable<float> scaleBindable = new BindableFloat();
-        private readonly IBindable<int> pathVersion = new Bindable<int>();
 
-        public DrawableSliderTail(Slider slider, SliderTailCircle hitCircle)
+        private readonly SkinnableDrawable circlePiece;
-            : base(hitCircle)
+
+        private readonly Container scaleContainer;
+
+        public DrawableSliderTail(Slider slider, SliderTailCircle tailCircle)
+            : base(tailCircle)
         {
-            this.slider = slider;
+            this.tailCircle = tailCircle;
-
             Origin = Anchor.Centre;
 
-            RelativeSizeAxes = Axes.Both;
+            Size = new Vector2(OsuHitObject.OBJECT_RADIUS * 2);
-            FillMode = FillMode.Fit;
 
-            AlwaysPresent = true;
+            InternalChildren = new Drawable[]
+            {
+                scaleContainer = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
+                    Children = new Drawable[]
+                    {
+                        // no default for this; only visible in legacy skins.
+                        circlePiece = new SkinnableDrawable(new OsuSkinComponent(OsuSkinComponents.SliderTailHitCircle), _ => Empty())
+                    }
+                },
+            };
+        }
 
-            positionBindable.BindTo(hitCircle.PositionBindable);
+        [BackgroundDependencyLoader]
-            pathVersion.BindTo(slider.Path.Version);
+        private void load()
+        {
+            scaleBindable.BindValueChanged(scale => scaleContainer.Scale = new Vector2(scale.NewValue), true);
+            scaleBindable.BindTo(HitObject.ScaleBindable);
+        }
 
-            positionBindable.BindValueChanged(_ => updatePosition());
+        protected override void UpdateInitialTransforms()
-            pathVersion.BindValueChanged(_ => updatePosition(), true);
+        {
+            base.UpdateInitialTransforms();
 
-            // TODO: This has no drawable content. Support for skins should be added.
+            circlePiece.FadeInFromZero(HitObject.TimeFadeIn);
+        }
+
+        protected override void UpdateStateTransforms(ArmedState state)
+        {
+            base.UpdateStateTransforms(state);
+
+            Debug.Assert(HitObject.HitWindows != null);
+
+            switch (state)
+            {
+                case ArmedState.Idle:
+                    this.Delay(HitObject.TimePreempt).FadeOut(500);
+
+                    Expire(true);
+                    break;
+
+                case ArmedState.Miss:
+                    this.FadeOut(100);
+                    break;
+
+                case ArmedState.Hit:
+                    // todo: temporary / arbitrary
+                    this.Delay(800).FadeOut();
+                    break;
+            }
         }
 
         protected override void CheckForResult(bool userTriggered, double timeOffset)
         {
             if (!userTriggered && timeOffset >= 0)
-                ApplyResult(r => r.Type = Tracking ? r.Judgement.MaxResult : HitResult.Miss);
+                ApplyResult(r => r.Type = Tracking ? r.Judgement.MaxResult : r.Judgement.MinResult);
         }
 
-        private void updatePosition() => Position = HitObject.Position - slider.Position;
+        public void UpdateSnakingPosition(Vector2 start, Vector2 end) =>
+            Position = tailCircle.RepeatIndex % 2 == 0 ? end : start;
     }
 }