Merge branch 'master' into judgement-cleanup

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

@@ -5,6 +5,7 @@ using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Judgements;
@@ -24,6 +25,8 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override bool UserScrollSpeedAdjustment => false;
 
+        protected override SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Constant;
+
         public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation)
             : base(BASE_WIDTH)
         {
@@ -55,6 +58,8 @@ namespace osu.Game.Rulesets.Catch.UI
                     RelativeSizeAxes = Axes.Both,
                 },
             });
+
+            VisibleTimeRange.Value = BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450);
         }
 
         public bool CheckIfWeCanCatch(CatchHitObject obj) => catcherArea.AttemptCatch(obj);

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

@@ -1,23 +1,24 @@
 // 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.Framework.Graphics.Shapes;
-using osu.Game.Rulesets.Taiko.Objects;
-using OpenTK;
-using OpenTK.Graphics;
-using osu.Game.Rulesets.Taiko.Judgements;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Graphics;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Extensions.Color4Extensions;
 using System.Linq;
-using osu.Game.Rulesets.Judgements;
+using osu.Framework.Allocation;
-using osu.Game.Rulesets.Taiko.Objects.Drawables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Rulesets.Taiko.Objects;
+using osu.Game.Rulesets.Taiko.Objects.Drawables;
+using osu.Game.Rulesets.Taiko.Judgements;
+using OpenTK;
+using OpenTK.Graphics;
 
 namespace osu.Game.Rulesets.Taiko.UI
 {
@@ -40,6 +41,8 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         protected override bool UserScrollSpeedAdjustment => false;
 
+        protected override SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Overlapping;
+
         private readonly Container<HitExplosion> hitExplosionContainer;
         private readonly Container<KiaiHitExplosion> kiaiExplosionContainer;
         private readonly JudgementContainer<DrawableTaikoJudgement> judgementContainer;

osu.Game/Configuration/OsuConfigManager.cs

@@ -83,8 +83,6 @@ namespace osu.Game.Configuration
 
             Set(OsuSetting.ScoreDisplayMode, ScoringMode.Standardised);
 
-            Set(OsuSetting.SpeedChangeVisualisation, SpeedChangeVisualisationMethod.Sequential);
-
             Set(OsuSetting.IncreaseFirstObjectVisibility, true);
 
             // Update
@@ -143,7 +141,6 @@ namespace osu.Game.Configuration
         ChatDisplayHeight,
         Version,
         ShowConvertedBeatmaps,
-        SpeedChangeVisualisation,
         Skin,
         ScreenshotFormat,
         ScreenshotCaptureMenuCursor,

osu.Game/Configuration/SpeedChangeVisualisationMethod.cs

@@ -10,6 +10,8 @@ namespace osu.Game.Configuration
         [Description("Sequential")]
         Sequential,
         [Description("Overlapping")]
-        Overlapping
+        Overlapping,
+        [Description("Constant")]
+        Constant
     }
 }

osu.Game/Overlays/Settings/Sections/Gameplay/ScrollingSettings.cs

@@ -1,26 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Allocation;
-using osu.Game.Configuration;
-
-namespace osu.Game.Overlays.Settings.Sections.Gameplay
-{
-    public class ScrollingSettings : SettingsSubsection
-    {
-        protected override string Header => "Scrolling";
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            Children = new[]
-            {
-                new SettingsEnumDropdown<SpeedChangeVisualisationMethod>
-                {
-                    LabelText = "Visualise speed changes as",
-                    Bindable = config.GetBindable<SpeedChangeVisualisationMethod>(OsuSetting.SpeedChangeVisualisation),
-                }
-            };
-        }
-    }
-}

osu.Game/Overlays/Settings/Sections/GameplaySection.cs

@@ -21,7 +21,6 @@ namespace osu.Game.Overlays.Settings.Sections
             {
                 new GeneralSettings(),
                 new SongSelectSettings(),
-                new ScrollingSettings(),
                 new ModsSettings(),
             };
         }
@@ -29,7 +28,7 @@ namespace osu.Game.Overlays.Settings.Sections
         [BackgroundDependencyLoader]
         private void load(RulesetStore rulesets)
         {
-            foreach(Ruleset ruleset in rulesets.AvailableRulesets.Select(info => info.CreateInstance()))
+            foreach (Ruleset ruleset in rulesets.AvailableRulesets.Select(info => info.CreateInstance()))
             {
                 SettingsSubsection section = ruleset.CreateSettings();
                 if (section != null)

osu.Game/Overlays/Settings/Sections/Graphics/LayoutSettings.cs

@@ -102,7 +102,7 @@ namespace osu.Game.Overlays.Settings.Sections.Graphics
                     }
                     else
                         resolutionDropdown.Hide();
-                });
+                }, true);
             }
 
             letterboxing.BindValueChanged(isVisible =>

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

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Allocation;
 using osu.Framework.Caching;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
@@ -33,20 +32,16 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
         private Cached initialStateCache = new Cached();
 
-        public ScrollingHitObjectContainer()
+        private readonly ISpeedChangeVisualiser speedChangeVisualiser;
+
+        public ScrollingHitObjectContainer(SpeedChangeVisualisationMethod visualisationMethod)
         {
             RelativeSizeAxes = Axes.Both;
 
             TimeRange.ValueChanged += _ => initialStateCache.Invalidate();
             Direction.ValueChanged += _ => initialStateCache.Invalidate();
-        }
 
-        private ISpeedChangeVisualiser speedChangeVisualiser;
+            switch (visualisationMethod)
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
-        {
-            switch (config.Get<SpeedChangeVisualisationMethod>(OsuSetting.SpeedChangeVisualisation))
             {
                 case SpeedChangeVisualisationMethod.Sequential:
                     speedChangeVisualiser = new SequentialSpeedChangeVisualiser(ControlPoints);
@@ -54,6 +49,9 @@ namespace osu.Game.Rulesets.UI.Scrolling
                 case SpeedChangeVisualisationMethod.Overlapping:
                     speedChangeVisualiser = new OverlappingSpeedChangeVisualiser(ControlPoints);
                     break;
+                case SpeedChangeVisualisationMethod.Constant:
+                    speedChangeVisualiser = new ConstantSpeedChangeVisualiser();
+                    break;
             }
         }
 

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

@@ -5,6 +5,7 @@ using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Bindings;
+using osu.Game.Configuration;
 using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Objects.Drawables;
 
@@ -62,6 +63,8 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </summary>
         protected readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
+        protected virtual SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Sequential;
+
         /// <summary>
         /// Creates a new <see cref="ScrollingPlayfield"/>.
         /// </summary>
@@ -104,7 +107,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
         protected sealed override HitObjectContainer CreateHitObjectContainer()
         {
-            var container = new ScrollingHitObjectContainer();
+            var container = new ScrollingHitObjectContainer(VisualisationMethod);
             container.Direction.BindTo(Direction);
             return container;
         }

osu.Game/Rulesets/UI/Scrolling/Visualisers/ConstantSpeedChangeVisualiser.cs

@@ -0,0 +1,67 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
+using OpenTK;
+
+namespace osu.Game.Rulesets.UI.Scrolling.Visualisers
+{
+    public class ConstantSpeedChangeVisualiser : ISpeedChangeVisualiser
+    {
+        public void ComputeInitialStates(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double timeRange, Vector2 length)
+        {
+            foreach (var obj in hitObjects)
+            {
+                obj.LifetimeStart = obj.HitObject.StartTime - timeRange;
+
+                if (obj.HitObject is IHasEndTime endTime)
+                {
+                    var hitObjectLength = (endTime.EndTime - obj.HitObject.StartTime) / timeRange;
+
+                    switch (direction)
+                    {
+                        case ScrollingDirection.Up:
+                        case ScrollingDirection.Down:
+                            obj.Height = (float)(hitObjectLength * length.Y);
+                            break;
+                        case ScrollingDirection.Left:
+                        case ScrollingDirection.Right:
+                            obj.Width = (float)(hitObjectLength * length.X);
+                            break;
+                    }
+                }
+
+                ComputeInitialStates(obj.NestedHitObjects, direction, timeRange, length);
+
+                // Nested hitobjects don't need to scroll, but they do need accurate positions
+                UpdatePositions(obj.NestedHitObjects, direction, obj.HitObject.StartTime, timeRange, length);
+            }
+        }
+
+        public void UpdatePositions(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double currentTime, double timeRange, Vector2 length)
+        {
+            foreach (var obj in hitObjects)
+            {
+                var position = (obj.HitObject.StartTime - currentTime) / timeRange;
+
+                switch (direction)
+                {
+                    case ScrollingDirection.Up:
+                        obj.Y = (float)(position * length.Y);
+                        break;
+                    case ScrollingDirection.Down:
+                        obj.Y = (float)(-position * length.Y);
+                        break;
+                    case ScrollingDirection.Left:
+                        obj.X = (float)(position * length.X);
+                        break;
+                    case ScrollingDirection.Right:
+                        obj.X = (float)(-position * length.X);
+                        break;
+                }
+            }
+        }
+    }
+}