diff --git a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
index b55b9fdb37..be670936fd 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs
@@ -28,12 +28,20 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         private Pattern lastPattern = new Pattern();
         private FastRandom random;
         private Beatmap beatmap;
-        private bool isForCurrentRuleset;
 
-        protected override Beatmap<ManiaHitObject> ConvertBeatmap(Beatmap original, bool isForCurrentRuleset)
+        private readonly int availableColumns;
+        private readonly bool isForCurrentRuleset;
+
+        public ManiaBeatmapConverter(bool isForCurrentRuleset, int availableColumns)
         {
-            this.isForCurrentRuleset = isForCurrentRuleset;
+            if (availableColumns <= 0) throw new ArgumentOutOfRangeException(nameof(availableColumns));
 
+            this.isForCurrentRuleset = isForCurrentRuleset;
+            this.availableColumns = availableColumns;
+        }
+
+        protected override Beatmap<ManiaHitObject> ConvertBeatmap(Beatmap original)
+        {
             beatmap = original;
 
             BeatmapDifficulty difficulty = original.BeatmapInfo.Difficulty;
@@ -41,7 +49,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             int seed = (int)Math.Round(difficulty.DrainRate + difficulty.CircleSize) * 20 + (int)(difficulty.OverallDifficulty * 41.2) + (int)Math.Round(difficulty.ApproachRate);
             random = new FastRandom(seed);
 
-            return base.ConvertBeatmap(original, isForCurrentRuleset);
+            return base.ConvertBeatmap(original);
         }
 
         protected override IEnumerable<ManiaHitObject> ConvertHitObject(HitObject original, Beatmap beatmap)
@@ -89,7 +97,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         /// <returns>The hit objects generated.</returns>
         private IEnumerable<ManiaHitObject> generateSpecific(HitObject original)
         {
-            var generator = new SpecificBeatmapPatternGenerator(random, original, beatmap, lastPattern);
+            var generator = new SpecificBeatmapPatternGenerator(random, original, beatmap, availableColumns, lastPattern);
 
             Pattern newPattern = generator.Generate();
             lastPattern = newPattern;
@@ -113,14 +121,14 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             Patterns.PatternGenerator conversion = null;
 
             if (distanceData != null)
-                conversion = new DistanceObjectPatternGenerator(random, original, beatmap, lastPattern);
+                conversion = new DistanceObjectPatternGenerator(random, original, beatmap, availableColumns, lastPattern);
             else if (endTimeData != null)
-                conversion = new EndTimeObjectPatternGenerator(random, original, beatmap);
+                conversion = new EndTimeObjectPatternGenerator(random, original, beatmap, availableColumns);
             else if (positionData != null)
             {
                 computeDensity(original.StartTime);
 
-                conversion = new HitObjectPatternGenerator(random, original, beatmap, lastPattern, lastTime, lastPosition, density, lastStair);
+                conversion = new HitObjectPatternGenerator(random, original, beatmap, availableColumns, lastPattern, lastTime, lastPosition, density, lastStair);
 
                 recordNote(original.StartTime, positionData.Position);
             }
@@ -142,8 +150,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
         /// </summary>
         private class SpecificBeatmapPatternGenerator : Patterns.Legacy.PatternGenerator
         {
-            public SpecificBeatmapPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
-                : base(random, hitObject, beatmap, previousPattern)
+            public SpecificBeatmapPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
+                : base(random, hitObject, beatmap, availableColumns, previousPattern)
             {
             }
 
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs
index c03a8438ae..20966a75f7 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/DistanceObjectPatternGenerator.cs
@@ -29,8 +29,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
         private PatternType convertType;
 
-        public DistanceObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
-            : base(random, hitObject, beatmap, previousPattern)
+        public DistanceObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
+            : base(random, hitObject, beatmap, availableColumns, previousPattern)
         {
             convertType = PatternType.None;
             if (Beatmap.ControlPointInfo.EffectPointAt(hitObject.StartTime).KiaiMode)
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs
index 6ad7489e0f..c353496410 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/EndTimeObjectPatternGenerator.cs
@@ -15,8 +15,8 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
     {
         private readonly double endTime;
 
-        public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap)
-            : base(random, hitObject, beatmap, new Pattern())
+        public EndTimeObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns)
+            : base(random, hitObject, beatmap, availableColumns, new Pattern())
         {
             var endtimeData = HitObject as IHasEndTime;
 
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/HitObjectPatternGenerator.cs b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/HitObjectPatternGenerator.cs
index 99f55cb98b..077b926635 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/HitObjectPatternGenerator.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/HitObjectPatternGenerator.cs
@@ -20,9 +20,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
         private readonly PatternType convertType;
 
-        public HitObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern, double previousTime, Vector2 previousPosition, double density, PatternType lastStair)
-            : base(random, hitObject, beatmap, previousPattern)
+        public HitObjectPatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern, double previousTime, Vector2 previousPosition, double density, PatternType lastStair)
+            : base(random, hitObject, beatmap, availableColumns, previousPattern)
         {
+            if (previousTime > hitObject.StartTime) throw new ArgumentOutOfRangeException(nameof(previousTime));
+            if (density < 0) throw new ArgumentOutOfRangeException(nameof(density));
+
             StairType = lastStair;
 
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PatternGenerator.cs b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PatternGenerator.cs
index b72618c36c..a3173f9784 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PatternGenerator.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PatternGenerator.cs
@@ -25,11 +25,15 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// </summary>
         protected readonly FastRandom Random;
 
-        protected PatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
-            : base(hitObject, beatmap, previousPattern)
+        protected PatternGenerator(FastRandom random, HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
+            : base(hitObject, beatmap, availableColumns, previousPattern)
         {
-            Random = random;
+            if (random == null) throw new ArgumentNullException(nameof(random));
+            if (beatmap == null) throw new ArgumentNullException(nameof(beatmap));
+            if (availableColumns <= 0) throw new ArgumentOutOfRangeException(nameof(availableColumns));
+            if (previousPattern == null) throw new ArgumentNullException(nameof(previousPattern));
 
+            Random = random;
             RandomStart = AvailableColumns == 8 ? 1 : 0;
         }
 
@@ -62,6 +66,12 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <returns>The amount of notes to be generated.</returns>
         protected int GetRandomNoteCount(double p2, double p3, double p4 = 0, double p5 = 0, double p6 = 0)
         {
+            if (p2 < 0 || p2 > 1) throw new ArgumentOutOfRangeException(nameof(p2));
+            if (p3 < 0 || p3 > 1) throw new ArgumentOutOfRangeException(nameof(p3));
+            if (p4 < 0 || p4 > 1) throw new ArgumentOutOfRangeException(nameof(p4));
+            if (p5 < 0 || p5 > 1) throw new ArgumentOutOfRangeException(nameof(p5));
+            if (p6 < 0 || p6 > 1) throw new ArgumentOutOfRangeException(nameof(p6));
+
             double val = Random.NextDouble();
             if (val >= 1 - p6)
                 return 6;
diff --git a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/PatternGenerator.cs b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/PatternGenerator.cs
index dda4d07182..ef321232c8 100644
--- a/osu.Game.Rulesets.Mania/Beatmaps/Patterns/PatternGenerator.cs
+++ b/osu.Game.Rulesets.Mania/Beatmaps/Patterns/PatternGenerator.cs
@@ -32,13 +32,17 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns
         /// </summary>
         protected readonly Beatmap Beatmap;
 
-        protected PatternGenerator(HitObject hitObject, Beatmap beatmap, Pattern previousPattern)
+        protected PatternGenerator(HitObject hitObject, Beatmap beatmap, int availableColumns, Pattern previousPattern)
         {
-            PreviousPattern = previousPattern;
+            if (hitObject == null) throw new ArgumentNullException(nameof(hitObject));
+            if (beatmap == null) throw new ArgumentNullException(nameof(beatmap));
+            if (availableColumns <= 0) throw new ArgumentOutOfRangeException(nameof(availableColumns));
+            if (previousPattern == null) throw new ArgumentNullException(nameof(previousPattern));
+
             HitObject = hitObject;
             Beatmap = beatmap;
-
-            AvailableColumns = (int)Math.Round(beatmap.BeatmapInfo.Difficulty.CircleSize);
+            AvailableColumns = availableColumns;
+            PreviousPattern = previousPattern;
         }
 
         /// <summary>
diff --git a/osu.Game.Rulesets.Mania/ManiaDifficultyCalculator.cs b/osu.Game.Rulesets.Mania/ManiaDifficultyCalculator.cs
index aaba4d94f0..1f01750f44 100644
--- a/osu.Game.Rulesets.Mania/ManiaDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Mania/ManiaDifficultyCalculator.cs
@@ -6,6 +6,7 @@ using osu.Game.Rulesets.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using System.Collections.Generic;
+using System;
 
 namespace osu.Game.Rulesets.Mania
 {
@@ -21,6 +22,6 @@ namespace osu.Game.Rulesets.Mania
             return 0;
         }
 
-        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter();
+        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter(true, (int)Math.Max(1, Math.Round(Beatmap.BeatmapInfo.Difficulty.CircleSize)));
     }
-}
\ No newline at end of file
+}
diff --git a/osu.Game.Rulesets.Mania/UI/ManiaPlayfield.cs b/osu.Game.Rulesets.Mania/UI/ManiaPlayfield.cs
index b836b54fa8..0c9351cad2 100644
--- a/osu.Game.Rulesets.Mania/UI/ManiaPlayfield.cs
+++ b/osu.Game.Rulesets.Mania/UI/ManiaPlayfield.cs
@@ -125,6 +125,7 @@ namespace osu.Game.Rulesets.Mania.UI
             for (int i = 0; i < columnCount; i++)
             {
                 var c = new Column();
+                c.Reversed.BindTo(Reversed);
                 c.VisibleTimeRange.BindTo(VisibleTimeRange);
 
                 columns.Add(c);
diff --git a/osu.Game.Rulesets.Mania/UI/ManiaRulesetContainer.cs b/osu.Game.Rulesets.Mania/UI/ManiaRulesetContainer.cs
index 9584dc34b8..0e750a348e 100644
--- a/osu.Game.Rulesets.Mania/UI/ManiaRulesetContainer.cs
+++ b/osu.Game.Rulesets.Mania/UI/ManiaRulesetContainer.cs
@@ -33,9 +33,10 @@ namespace osu.Game.Rulesets.Mania.UI
     public class ManiaRulesetContainer : ScrollingRulesetContainer<ManiaPlayfield, ManiaHitObject, ManiaJudgement>
     {
         /// <summary>
-        /// Preferred column count. This will only have an effect during the initialization of the play field.
+        /// The number of columns which the <see cref="ManiaPlayfield"/> should display, and which
+        /// the beatmap converter will attempt to convert beatmaps to use.
         /// </summary>
-        public int PreferredColumns;
+        private int availableColumns;
 
         public IEnumerable<DrawableBarLine> BarLines;
 
@@ -76,26 +77,35 @@ namespace osu.Game.Rulesets.Mania.UI
             BarLines.ForEach(Playfield.Add);
         }
 
-        protected override void ApplyBeatmap()
-        {
-            base.ApplyBeatmap();
-
-            PreferredColumns = (int)Math.Max(1, Math.Round(Beatmap.BeatmapInfo.Difficulty.CircleSize));
-        }
-
-        protected sealed override Playfield<ManiaHitObject, ManiaJudgement> CreatePlayfield() => new ManiaPlayfield(PreferredColumns)
+        protected sealed override Playfield<ManiaHitObject, ManiaJudgement> CreatePlayfield() => new ManiaPlayfield(availableColumns)
         {
             Anchor = Anchor.Centre,
             Origin = Anchor.Centre,
-            // Invert by default for now (should be moved to config/skin later)
-            Scale = new Vector2(1, -1)
         };
 
         public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor(this);
 
         public override PassThroughInputManager CreateInputManager() => new ManiaInputManager(Ruleset.RulesetInfo);
 
-        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter() => new ManiaBeatmapConverter();
+        protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter()
+        {
+            if (IsForCurrentRuleset)
+                availableColumns = (int)Math.Max(1, Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.CircleSize));
+            else
+            {
+                float percentSliderOrSpinner = (float)WorkingBeatmap.Beatmap.HitObjects.Count(h => h is IHasEndTime) / WorkingBeatmap.Beatmap.HitObjects.Count;
+                if (percentSliderOrSpinner < 0.2)
+                    availableColumns = 7;
+                else if (percentSliderOrSpinner < 0.3 || Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.CircleSize) >= 5)
+                    availableColumns = Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.OverallDifficulty) > 5 ? 7 : 6;
+                else if (percentSliderOrSpinner > 0.6)
+                    availableColumns = Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.OverallDifficulty) > 4 ? 5 : 4;
+                else
+                    availableColumns = Math.Max(4, Math.Min((int)Math.Round(WorkingBeatmap.BeatmapInfo.Difficulty.OverallDifficulty) + 1, 7));
+            }
+
+            return new ManiaBeatmapConverter(IsForCurrentRuleset, availableColumns);
+        }
 
         protected override DrawableHitObject<ManiaHitObject, ManiaJudgement> GetVisualRepresentation(ManiaHitObject h)
         {
diff --git a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
index 869d54dded..2bf058fc2b 100644
--- a/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
+++ b/osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs
@@ -39,19 +39,22 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
         /// </summary>
         private const float taiko_base_distance = 100;
 
-        private bool isForCurrentRuleset;
+        private readonly bool isForCurrentRuleset;
 
         protected override IEnumerable<Type> ValidConversionTypes { get; } = new[] { typeof(HitObject) };
 
-        protected override Beatmap<TaikoHitObject> ConvertBeatmap(Beatmap original, bool isForCurrentRuleset)
+        public TaikoBeatmapConverter(bool isForCurrentRuleset)
         {
             this.isForCurrentRuleset = isForCurrentRuleset;
+        }
 
+        protected override Beatmap<TaikoHitObject> ConvertBeatmap(Beatmap original)
+        {
             // Rewrite the beatmap info to add the slider velocity multiplier
             BeatmapInfo info = original.BeatmapInfo.DeepClone();
             info.Difficulty.SliderMultiplier *= legacy_velocity_multiplier;
 
-            Beatmap<TaikoHitObject> converted = base.ConvertBeatmap(original, isForCurrentRuleset);
+            Beatmap<TaikoHitObject> converted = base.ConvertBeatmap(original);
 
             // Post processing step to transform hit objects with the same start time into strong hits
             converted.HitObjects = converted.HitObjects.GroupBy(t => t.StartTime).Select(x =>
diff --git a/osu.Game.Rulesets.Taiko/TaikoDifficultyCalculator.cs b/osu.Game.Rulesets.Taiko/TaikoDifficultyCalculator.cs
index 33e9510f1c..35f849c704 100644
--- a/osu.Game.Rulesets.Taiko/TaikoDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/TaikoDifficultyCalculator.cs
@@ -135,6 +135,6 @@ namespace osu.Game.Rulesets.Taiko
             return difficulty;
         }
 
-        protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter() => new TaikoBeatmapConverter();
+        protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter() => new TaikoBeatmapConverter(true);
     }
-}
\ No newline at end of file
+}
diff --git a/osu.Game.Rulesets.Taiko/UI/TaikoRulesetContainer.cs b/osu.Game.Rulesets.Taiko/UI/TaikoRulesetContainer.cs
index 1ecd699a8e..96e5df12cd 100644
--- a/osu.Game.Rulesets.Taiko/UI/TaikoRulesetContainer.cs
+++ b/osu.Game.Rulesets.Taiko/UI/TaikoRulesetContainer.cs
@@ -91,7 +91,7 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         public override ScoreProcessor CreateScoreProcessor() => new TaikoScoreProcessor(this);
 
-        protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter() => new TaikoBeatmapConverter();
+        protected override BeatmapConverter<TaikoHitObject> CreateBeatmapConverter() => new TaikoBeatmapConverter(IsForCurrentRuleset);
 
         public override PassThroughInputManager CreateInputManager() => new TaikoInputManager(Ruleset.RulesetInfo);
 
diff --git a/osu.Game/Beatmaps/DifficultyCalculator.cs b/osu.Game/Beatmaps/DifficultyCalculator.cs
index 474d38aa1b..5071e2c1b6 100644
--- a/osu.Game/Beatmaps/DifficultyCalculator.cs
+++ b/osu.Game/Beatmaps/DifficultyCalculator.cs
@@ -30,11 +30,15 @@ namespace osu.Game.Beatmaps
 
     public abstract class DifficultyCalculator<T> : DifficultyCalculator where T : HitObject
     {
+        protected readonly Beatmap Beatmap;
+
         protected List<T> Objects;
 
         protected DifficultyCalculator(Beatmap beatmap)
         {
-            Objects = CreateBeatmapConverter().Convert(beatmap, true).HitObjects;
+            Beatmap = beatmap;
+
+            Objects = CreateBeatmapConverter().Convert(beatmap).HitObjects;
 
             foreach (var h in Objects)
                 h.ApplyDefaults(beatmap.ControlPointInfo, beatmap.BeatmapInfo.Difficulty);
diff --git a/osu.Game/Rulesets/Beatmaps/BeatmapConverter.cs b/osu.Game/Rulesets/Beatmaps/BeatmapConverter.cs
index aafa576d4b..e79d9eee4b 100644
--- a/osu.Game/Rulesets/Beatmaps/BeatmapConverter.cs
+++ b/osu.Game/Rulesets/Beatmaps/BeatmapConverter.cs
@@ -26,21 +26,19 @@ namespace osu.Game.Rulesets.Beatmaps
         /// Converts a Beatmap using this Beatmap Converter.
         /// </summary>
         /// <param name="original">The un-converted Beatmap.</param>
-        /// <param name="isForCurrentRuleset">Whether to assume the beatmap is for the current ruleset.</param>
         /// <returns>The converted Beatmap.</returns>
-        public Beatmap<T> Convert(Beatmap original, bool isForCurrentRuleset)
+        public Beatmap<T> Convert(Beatmap original)
         {
             // We always operate on a clone of the original beatmap, to not modify it game-wide
-            return ConvertBeatmap(new Beatmap(original), isForCurrentRuleset);
+            return ConvertBeatmap(new Beatmap(original));
         }
 
         /// <summary>
         /// Performs the conversion of a Beatmap using this Beatmap Converter.
         /// </summary>
         /// <param name="original">The un-converted Beatmap.</param>
-        /// <param name="isForCurrentRuleset">Whether to assume the beatmap is for the current ruleset.</param>
         /// <returns>The converted Beatmap.</returns>
-        protected virtual Beatmap<T> ConvertBeatmap(Beatmap original, bool isForCurrentRuleset)
+        protected virtual Beatmap<T> ConvertBeatmap(Beatmap original)
         {
             return new Beatmap<T>
             {
diff --git a/osu.Game/Rulesets/UI/RulesetContainer.cs b/osu.Game/Rulesets/UI/RulesetContainer.cs
index 50fcaa128c..2f1cb915f3 100644
--- a/osu.Game/Rulesets/UI/RulesetContainer.cs
+++ b/osu.Game/Rulesets/UI/RulesetContainer.cs
@@ -139,16 +139,30 @@ namespace osu.Game.Rulesets.UI
         protected IEnumerable<Mod> Mods;
 
         /// <summary>
+        /// The <see cref="WorkingBeatmap"/> this <see cref="RulesetContainer{TObject}"/> was created with.
+        /// </summary>
+        protected readonly WorkingBeatmap WorkingBeatmap;
+
+        /// <summary>
+        /// Whether the specified beatmap is assumed to be specific to the current ruleset.
+        /// </summary>
+        protected readonly bool IsForCurrentRuleset;
+
+        /// <summary>
+        /// Whether to assume the beatmap passed into this <see cref="RulesetContainer{TObject}"/> is for the current ruleset.
         /// Creates a hit renderer for a beatmap.
         /// </summary>
         /// <param name="ruleset">The ruleset being repesented.</param>
-        /// <param name="beatmap">The beatmap to create the hit renderer for.</param>
+        /// <param name="workingBeatmap">The beatmap to create the hit renderer for.</param>
         /// <param name="isForCurrentRuleset">Whether to assume the beatmap is for the current ruleset.</param>
-        internal RulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap, bool isForCurrentRuleset) : base(ruleset)
+        internal RulesetContainer(Ruleset ruleset, WorkingBeatmap workingBeatmap, bool isForCurrentRuleset)
+            : base(ruleset)
         {
-            Debug.Assert(beatmap != null, "RulesetContainer initialized with a null beatmap.");
+            Debug.Assert(workingBeatmap != null, "RulesetContainer initialized with a null beatmap.");
 
-            Mods = beatmap.Mods.Value;
+            WorkingBeatmap = workingBeatmap;
+            IsForCurrentRuleset = isForCurrentRuleset;
+            Mods = workingBeatmap.Mods.Value;
 
             RelativeSizeAxes = Axes.Both;
 
@@ -156,11 +170,11 @@ namespace osu.Game.Rulesets.UI
             BeatmapProcessor<TObject> processor = CreateBeatmapProcessor();
 
             // Check if the beatmap can be converted
-            if (!converter.CanConvert(beatmap.Beatmap))
+            if (!converter.CanConvert(workingBeatmap.Beatmap))
                 throw new BeatmapInvalidForRulesetException($"{nameof(Beatmap)} can not be converted for the current ruleset (converter: {converter}).");
 
             // Convert the beatmap
-            Beatmap = converter.Convert(beatmap.Beatmap, isForCurrentRuleset);
+            Beatmap = converter.Convert(workingBeatmap.Beatmap);
 
             // Apply difficulty adjustments from mods before using Difficulty.
             foreach (var mod in Mods.OfType<IApplicableToDifficulty>())
@@ -173,8 +187,6 @@ namespace osu.Game.Rulesets.UI
             // Post-process the beatmap
             processor.PostProcess(Beatmap);
 
-            ApplyBeatmap();
-
             // Add mods, should always be the last thing applied to give full control to mods
             applyMods(Mods);
         }
@@ -192,11 +204,6 @@ namespace osu.Game.Rulesets.UI
                 mod.ApplyToRulesetContainer(this);
         }
 
-        /// <summary>
-        /// Called when the beatmap of this hit renderer has been set. Used to apply any default values from the beatmap.
-        /// </summary>
-        protected virtual void ApplyBeatmap() { }
-
         /// <summary>
         /// Creates a processor to perform post-processing operations
         /// on HitObjects in converted Beatmaps.
diff --git a/osu.Game/Rulesets/UI/ScrollingRulesetContainer.cs b/osu.Game/Rulesets/UI/ScrollingRulesetContainer.cs
index 64e865473d..ff156f788c 100644
--- a/osu.Game/Rulesets/UI/ScrollingRulesetContainer.cs
+++ b/osu.Game/Rulesets/UI/ScrollingRulesetContainer.cs
@@ -39,17 +39,6 @@ namespace osu.Game.Rulesets.UI
 
         [BackgroundDependencyLoader]
         private void load()
-        {
-            DefaultControlPoints.ForEach(c => applySpeedAdjustment(c, Playfield));
-        }
-
-        private void applySpeedAdjustment(MultiplierControlPoint controlPoint, ScrollingPlayfield<TObject, TJudgement> playfield)
-        {
-            playfield.HitObjects.AddSpeedAdjustment(CreateSpeedAdjustmentContainer(controlPoint));
-            playfield.NestedPlayfields.ForEach(p => applySpeedAdjustment(controlPoint, p));
-        }
-
-        protected override void ApplyBeatmap()
         {
             // Calculate default multiplier control points
             var lastTimingPoint = new TimingControlPoint();
@@ -95,6 +84,14 @@ namespace osu.Game.Rulesets.UI
             // If we have no control points, add a default one
             if (DefaultControlPoints.Count == 0)
                 DefaultControlPoints.Add(new MultiplierControlPoint());
+
+            DefaultControlPoints.ForEach(c => applySpeedAdjustment(c, Playfield));
+        }
+
+        private void applySpeedAdjustment(MultiplierControlPoint controlPoint, ScrollingPlayfield<TObject, TJudgement> playfield)
+        {
+            playfield.HitObjects.AddSpeedAdjustment(CreateSpeedAdjustmentContainer(controlPoint));
+            playfield.NestedPlayfields.ForEach(p => applySpeedAdjustment(controlPoint, p));
         }
 
         /// <summary>