Add mania direction to settings

osu.Game.Rulesets.Mania/Configuration/ManiaConfigManager.cs

@@ -4,6 +4,7 @@
 using osu.Framework.Configuration.Tracking;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Configuration;
+using osu.Game.Rulesets.Mania.UI;
 
 namespace osu.Game.Rulesets.Mania.Configuration
 {
@@ -19,6 +20,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
             base.InitialiseDefaults();
 
             Set(ManiaSetting.ScrollTime, 1500.0, 50.0, 10000.0, 50.0);
+            Set(ManiaSetting.ScrollDirection, ManiaScrollingDirection.Up);
         }
 
         public override TrackedSettings CreateTrackedSettings() => new TrackedSettings
@@ -29,6 +31,7 @@ namespace osu.Game.Rulesets.Mania.Configuration
 
     public enum ManiaSetting
     {
-        ScrollTime
+        ScrollTime,
+        ScrollDirection
     }
 }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -16,6 +16,7 @@ using osu.Game.Rulesets.Mania.Replays;
 using osu.Game.Rulesets.Replays.Types;
 using osu.Game.Beatmaps.Legacy;
 using osu.Game.Configuration;
+using osu.Game.Overlays.Settings;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -155,6 +156,8 @@ namespace osu.Game.Rulesets.Mania
 
         public override IRulesetConfigManager CreateConfig(SettingsStore settings) => new ManiaConfigManager(settings, RulesetInfo);
 
+        public override RulesetSettingsSubsection CreateSettings() => new ManiaSettingsSubsection(this);
+
         public ManiaRuleset(RulesetInfo rulesetInfo = null)
             : base(rulesetInfo)
         {

osu.Game.Rulesets.Mania/ManiaSettingsSubsection.cs

@@ -0,0 +1,34 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Game.Overlays.Settings;
+using osu.Game.Rulesets.Mania.Configuration;
+using osu.Game.Rulesets.Mania.UI;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class ManiaSettingsSubsection : RulesetSettingsSubsection
+    {
+        protected override string Header => "osu!mania";
+
+        public ManiaSettingsSubsection(ManiaRuleset ruleset)
+            : base(ruleset)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ManiaConfigManager config)
+        {
+            Children = new Drawable[]
+            {
+                new SettingsEnumDropdown<ManiaScrollingDirection>
+                {
+                    LabelText = "Scrolling direction",
+                    Bindable = config.GetBindable<ManiaScrollingDirection>(ManiaSetting.ScrollDirection)
+                }
+            };
+        }
+    }
+}

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

@@ -14,7 +14,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class Column : ScrollingPlayfield, IKeyBindingHandler<ManiaAction>, IHasAccentColour
+    public class Column : ManiaScrollingPlayfield, IKeyBindingHandler<ManiaAction>, IHasAccentColour
     {
         private const float column_width = 45;
         private const float special_column_width = 70;
@@ -35,8 +35,6 @@ namespace osu.Game.Rulesets.Mania.UI
             }
         }
 
-        private readonly ScrollingDirection direction;
-
         private readonly ColumnBackground background;
         private readonly ColumnKeyArea keyArea;
         private readonly ColumnHitObjectArea hitObjectArea;
@@ -49,7 +47,6 @@ namespace osu.Game.Rulesets.Mania.UI
         public Column(ScrollingDirection direction)
             : base(direction)
         {
-            this.direction = direction;
             RelativeSizeAxes = Axes.Y;
             Width = column_width;
 
@@ -58,19 +55,16 @@ namespace osu.Game.Rulesets.Mania.UI
 
             background = new ColumnBackground { RelativeSizeAxes = Axes.Both };
 
+            Container hitTargetContainer;
+
             InternalChildren = new[]
             {
                 // For input purposes, the background is added at the highest depth, but is then proxied back below all other elements
                 background.CreateProxy(),
-                new Container
+                hitTargetContainer = new Container
                 {
                     Name = "Hit target + hit objects",
                     RelativeSizeAxes = Axes.Both,
-                    Padding = new MarginPadding
-                    {
-                        Top = direction == ScrollingDirection.Up ? ManiaStage.HIT_TARGET_POSITION : 0,
-                        Bottom = direction == ScrollingDirection.Down ? ManiaStage.HIT_TARGET_POSITION : 0,
-                    },
                     Children = new Drawable[]
                     {
                         hitObjectArea = new ColumnHitObjectArea { RelativeSizeAxes = Axes.Both },
@@ -83,8 +77,6 @@ namespace osu.Game.Rulesets.Mania.UI
                 },
                 keyArea = new ColumnKeyArea
                 {
-                    Anchor = direction == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft,
-                    Origin = direction == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft,
                     RelativeSizeAxes = Axes.X,
                     Height = ManiaStage.HIT_TARGET_POSITION,
                 },
@@ -93,6 +85,18 @@ namespace osu.Game.Rulesets.Mania.UI
             };
 
             TopLevelContainer.Add(explosionContainer.CreateProxy());
+
+            Direction.BindValueChanged(d =>
+            {
+                hitTargetContainer.Padding = new MarginPadding
+                {
+                    Top = d == ScrollingDirection.Up ? ManiaStage.HIT_TARGET_POSITION : 0,
+                    Bottom = d == ScrollingDirection.Down ? ManiaStage.HIT_TARGET_POSITION : 0,
+                };
+
+                keyArea.Anchor = d == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
+                keyArea.Origin = d == ScrollingDirection.Up ? Anchor.TopLeft : Anchor.BottomLeft;
+            }, true);
         }
 
         public override Axes RelativeSizeAxes => Axes.Y;
@@ -146,7 +150,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
             explosionContainer.Add(new HitExplosion(judgedObject)
             {
-                Anchor = direction == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre
+                Anchor = Direction == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre
             });
         }
 

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

@@ -16,7 +16,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class ManiaPlayfield : ScrollingPlayfield
+    public class ManiaPlayfield : ManiaScrollingPlayfield
     {
         public List<Column> Columns => stages.SelectMany(x => x.Columns).ToList();
         private readonly List<ManiaStage> stages = new List<ManiaStage>();

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

@@ -13,6 +13,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Input.Handlers;
 using osu.Game.Rulesets.Mania.Beatmaps;
+using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Mods;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
@@ -34,6 +35,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public IEnumerable<BarLine> BarLines;
 
+        private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
         private ScrollingInfo scrollingInfo;
 
         public ManiaRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
@@ -68,9 +70,12 @@ namespace osu.Game.Rulesets.Mania.UI
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(ManiaConfigManager config)
         {
             BarLines.ForEach(Playfield.Add);
+
+            config.BindWith(ManiaSetting.ScrollDirection, configDirection);
+            configDirection.BindValueChanged(d => scrollingInfo.Direction.Value = (ScrollingDirection)d, true);
         }
 
         private DependencyContainer dependencies;
@@ -78,11 +83,7 @@ namespace osu.Game.Rulesets.Mania.UI
         protected override IReadOnlyDependencyContainer CreateLocalDependencies(IReadOnlyDependencyContainer parent)
         {
             dependencies = new DependencyContainer(base.CreateLocalDependencies(parent));
-
+            dependencies.CacheAs<IScrollingInfo>(scrollingInfo = new ScrollingInfo());
-            scrollingInfo = new ScrollingInfo { Direction = { Value = ScrollingDirection.Up } };
-
-            dependencies.CacheAs<IScrollingInfo>(scrollingInfo);
-
             return dependencies;
         }
 

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

@@ -0,0 +1,13 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.UI.Scrolling;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public enum ManiaScrollingDirection
+    {
+        Up = ScrollingDirection.Up,
+        Down = ScrollingDirection.Down
+    }
+}

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

@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Game.Rulesets.UI.Scrolling;
+
+namespace osu.Game.Rulesets.Mania.UI
+{
+    public class ManiaScrollingPlayfield : ScrollingPlayfield
+    {
+        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
+
+        public ManiaScrollingPlayfield(ScrollingDirection direction)
+            : base(direction)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(IScrollingInfo scrollingInfo)
+        {
+            direction.BindTo(scrollingInfo.Direction);
+            direction.BindValueChanged(direction => Direction.Value = direction, true);
+        }
+    }
+}

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

@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Mania.UI
     /// <summary>
     /// A collection of <see cref="Column"/>s.
     /// </summary>
-    internal class ManiaStage : ScrollingPlayfield
+    internal class ManiaStage : ManiaScrollingPlayfield
     {
         public const float HIT_TARGET_POSITION = 50;
 

osu.Game/Configuration/OsuConfigManager.cs

@@ -147,6 +147,6 @@ namespace osu.Game.Configuration
         SongSelectRightMouseScroll,
         BeatmapSkins,
         BeatmapHitsounds,
-        IncreaseFirstObjectVisibility
+        IncreaseFirstObjectVisibility,
     }
 }

osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs

@@ -29,17 +29,16 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </summary>
         protected readonly SortedList<MultiplierControlPoint> ControlPoints = new SortedList<MultiplierControlPoint>();
 
-        private readonly ScrollingDirection direction;
+        public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
         private Cached initialStateCache = new Cached();
 
-        public ScrollingHitObjectContainer(ScrollingDirection direction)
+        public ScrollingHitObjectContainer()
         {
-            this.direction = direction;
-
             RelativeSizeAxes = Axes.Both;
 
-            TimeRange.ValueChanged += v => initialStateCache.Invalidate();
+            TimeRange.ValueChanged += _ => initialStateCache.Invalidate();
+            Direction.ValueChanged += _ => initialStateCache.Invalidate();
         }
 
         private ISpeedChangeVisualiser speedChangeVisualiser;
@@ -100,7 +99,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
             if (!initialStateCache.IsValid)
             {
-                speedChangeVisualiser.ComputeInitialStates(Objects, direction, TimeRange, DrawSize);
+                speedChangeVisualiser.ComputeInitialStates(Objects, Direction, TimeRange, DrawSize);
                 initialStateCache.Validate();
             }
         }
@@ -110,7 +109,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
             base.UpdateAfterChildrenLife();
 
             // We need to calculate this as soon as possible after lifetimes so that hitobjects get the final say in their positions
-            speedChangeVisualiser.UpdatePositions(AliveObjects, direction, Time.Current, TimeRange, DrawSize);
+            speedChangeVisualiser.UpdatePositions(AliveObjects, Direction, Time.Current, TimeRange, DrawSize);
         }
     }
 }

osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs

@@ -54,7 +54,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </summary>
         public new ScrollingHitObjectContainer HitObjects => (ScrollingHitObjectContainer)base.HitObjects;
 
-        private readonly ScrollingDirection direction;
+        protected readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
         /// <summary>
         /// Creates a new <see cref="ScrollingPlayfield"/>.
@@ -69,7 +69,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         protected ScrollingPlayfield(ScrollingDirection direction, float? customWidth = null, float? customHeight = null)
             : base(customWidth, customHeight)
         {
-            this.direction = direction;
+            Direction.Value = direction;
         }
 
         [BackgroundDependencyLoader]
@@ -99,6 +99,11 @@ namespace osu.Game.Rulesets.UI.Scrolling
             return false;
         }
 
-        protected sealed override HitObjectContainer CreateHitObjectContainer() => new ScrollingHitObjectContainer(direction);
+        protected sealed override HitObjectContainer CreateHitObjectContainer()
+        {
+            var container = new ScrollingHitObjectContainer();
+            container.Direction.BindTo(Direction);
+            return container;
+        }
     }
 }