Merge branch 'master' into editor-new-beatmap

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

@@ -14,6 +14,7 @@ using osu.Game.Tests.Beatmaps;
 namespace osu.Game.Rulesets.Catch.Tests
 {
     [TestFixture]
+    [Timeout(10000)]
     public class CatchBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Catch";

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

@@ -14,11 +14,13 @@ using osu.Game.Tests.Beatmaps;
 namespace osu.Game.Rulesets.Mania.Tests
 {
     [TestFixture]
+    [Timeout(10000)]
     public class ManiaBeatmapConversionTest : BeatmapConversionTest<ManiaConvertMapping, ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Mania";
 
         [TestCase("basic")]
+        [TestCase("zero-length-slider")]
         public void Test(string name) => base.Test(name);
 
         protected override IEnumerable<ConvertValue> CreateConvertValue(HitObject hitObject)

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

@@ -5,7 +5,6 @@ using osu.Game.Rulesets.Mania.Objects;
 using System;
 using System.Linq;
 using System.Collections.Generic;
-using osu.Framework.Utils;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
@@ -167,8 +166,10 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
 
                     var positionData = original as IHasPosition;
 
-                    for (double time = original.StartTime; !Precision.DefinitelyBigger(time, generator.EndTime); time += generator.SegmentDuration)
+                    for (int i = 0; i <= generator.SpanCount; i++)
                     {
+                        double time = original.StartTime + generator.SegmentDuration * i;
+
                         recordNote(time, positionData?.Position ?? Vector2.Zero);
                         computeDensity(time);
                     }

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

@@ -27,8 +27,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
         public readonly double EndTime;
         public readonly double SegmentDuration;
-
-        private readonly int spanCount;
+        public readonly int SpanCount;
 
         private PatternType convertType;
 
@@ -42,20 +41,20 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             var distanceData = hitObject as IHasDistance;
             var repeatsData = hitObject as IHasRepeats;
 
-            spanCount = repeatsData?.SpanCount() ?? 1;
+            SpanCount = repeatsData?.SpanCount() ?? 1;
 
             TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(hitObject.StartTime);
             DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(hitObject.StartTime);
 
             // The true distance, accounting for any repeats
-            double distance = (distanceData?.Distance ?? 0) * spanCount;
+            double distance = (distanceData?.Distance ?? 0) * SpanCount;
             // The velocity of the osu! hit object - calculated as the velocity of a slider
             double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier / timingPoint.BeatLength;
             // The duration of the osu! hit object
             double osuDuration = distance / osuVelocity;
 
             EndTime = hitObject.StartTime + osuDuration;
-            SegmentDuration = (EndTime - HitObject.StartTime) / spanCount;
+            SegmentDuration = (EndTime - HitObject.StartTime) / SpanCount;
         }
 
         public override IEnumerable<Pattern> Generate()
@@ -96,7 +95,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 return pattern;
             }
 
-            if (spanCount > 1)
+            if (SpanCount > 1)
             {
                 if (SegmentDuration <= 90)
                     return generateRandomHoldNotes(HitObject.StartTime, 1);
@@ -104,7 +103,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 if (SegmentDuration <= 120)
                 {
                     convertType |= PatternType.ForceNotStack;
-                    return generateRandomNotes(HitObject.StartTime, spanCount + 1);
+                    return generateRandomNotes(HitObject.StartTime, SpanCount + 1);
                 }
 
                 if (SegmentDuration <= 160)
@@ -117,7 +116,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
                 if (duration >= 4000)
                     return generateNRandomNotes(HitObject.StartTime, 0.23, 0, 0);
 
-                if (SegmentDuration > 400 && spanCount < TotalColumns - 1 - RandomStart)
+                if (SegmentDuration > 400 && SpanCount < TotalColumns - 1 - RandomStart)
                     return generateTiledHoldNotes(HitObject.StartTime);
 
                 return generateHoldAndNormalNotes(HitObject.StartTime);
@@ -251,7 +250,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
             int column = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
             bool increasing = Random.NextDouble() > 0.5;
 
-            for (int i = 0; i <= spanCount; i++)
+            for (int i = 0; i <= SpanCount; i++)
             {
                 addToPattern(pattern, column, startTime, startTime);
                 startTime += SegmentDuration;
@@ -302,7 +301,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
 
-            for (int i = 0; i <= spanCount; i++)
+            for (int i = 0; i <= SpanCount; i++)
             {
                 addToPattern(pattern, nextColumn, startTime, startTime);
 
@@ -393,7 +392,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             var pattern = new Pattern();
 
-            int columnRepeat = Math.Min(spanCount, TotalColumns);
+            int columnRepeat = Math.Min(SpanCount, TotalColumns);
 
             int nextColumn = GetColumn((HitObject as IHasXPosition)?.X ?? 0, true);
             if (convertType.HasFlag(PatternType.ForceNotStack) && PreviousPattern.ColumnWithObjects < TotalColumns)
@@ -447,7 +446,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 
             var rowPattern = new Pattern();
 
-            for (int i = 0; i <= spanCount; i++)
+            for (int i = 0; i <= SpanCount; i++)
             {
                 if (!(ignoreHead && startTime == HitObject.StartTime))
                 {

osu.Game.Rulesets.Mania/Resources/Testing/Beatmaps/zero-length-slider-expected-conversion.json

@@ -0,0 +1,14 @@
+{
+    "Mappings": [{
+        "RandomW": 3083084786,
+        "RandomX": 273326509,
+        "RandomY": 273553282,
+        "RandomZ": 2659838971,
+        "StartTime": 4836,
+        "Objects": [{
+            "StartTime": 4836,
+            "EndTime": 4836,
+            "Column": 0
+        }]
+    }]
+}

osu.Game.Rulesets.Mania/Resources/Testing/Beatmaps/zero-length-slider.osu

@@ -0,0 +1,20 @@
+osu file format v14
+
+[General]
+StackLeniency: 0.7
+Mode: 0
+
+[Difficulty]
+HPDrainRate:1
+CircleSize:4
+OverallDifficulty:1
+ApproachRate:9
+SliderMultiplier:2.5
+SliderTickRate:0.5
+
+[TimingPoints]
+34,431.654676258993,4,1,0,50,1,0
+4782,-66.6666666666667,4,1,0,20,0,0
+
+[HitObjects]
+15,199,4836,22,0,L,1,46.8750017881394

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

@@ -12,6 +12,7 @@ using osu.Game.Tests.Beatmaps;
 namespace osu.Game.Rulesets.Osu.Tests
 {
     [TestFixture]
+    [Timeout(10000)]
     public class OsuBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Osu";

osu.Game.Rulesets.Osu/Skinning/LegacySliderBody.cs

@@ -18,6 +18,10 @@ namespace osu.Game.Rulesets.Osu.Skinning
         {
             private const float shadow_portion = 1 - (OsuLegacySkinTransformer.LEGACY_CIRCLE_RADIUS / OsuHitObject.OBJECT_RADIUS);
 
+            protected new float CalculatedBorderPortion
+                // Roughly matches osu!stable's slider border portions.
+                => base.CalculatedBorderPortion * 0.77f;
+
             public new Color4 AccentColour => new Color4(base.AccentColour.R, base.AccentColour.G, base.AccentColour.B, base.AccentColour.A * 0.70f);
 
             protected override Color4 ColourAt(float position)

osu.Game.Rulesets.Taiko.Tests/TaikoBeatmapConversionTest.cs

@@ -12,6 +12,7 @@ using osu.Game.Tests.Beatmaps;
 namespace osu.Game.Rulesets.Taiko.Tests
 {
     [TestFixture]
+    [Timeout(10000)]
     public class TaikoBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Taiko";

osu.Game.Tests/Visual/Gameplay/TestSceneOverlayActivation.cs

@@ -0,0 +1,54 @@
+// 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.Game.Overlays;
+using osu.Game.Rulesets;
+
+namespace osu.Game.Tests.Visual.Gameplay
+{
+    public class TestSceneOverlayActivation : OsuPlayerTestScene
+    {
+        protected new OverlayTestPlayer Player => base.Player as OverlayTestPlayer;
+
+        [Test]
+        public void TestGameplayOverlayActivation()
+        {
+            AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+        }
+
+        [Test]
+        public void TestGameplayOverlayActivationPaused()
+        {
+            AddUntilStep("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddStep("pause gameplay", () => Player.Pause());
+            AddUntilStep("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
+        }
+
+        [Test]
+        public void TestGameplayOverlayActivationReplayLoaded()
+        {
+            AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddStep("load a replay", () => Player.DrawableRuleset.HasReplayLoaded.Value = true);
+            AddAssert("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
+        }
+
+        [Test]
+        public void TestGameplayOverlayActivationBreaks()
+        {
+            AddAssert("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+            AddStep("seek to break", () => Player.GameplayClockContainer.Seek(Beatmap.Value.Beatmap.Breaks.First().StartTime));
+            AddUntilStep("activation mode is user triggered", () => Player.OverlayActivationMode == OverlayActivation.UserTriggered);
+            AddStep("seek to break end", () => Player.GameplayClockContainer.Seek(Beatmap.Value.Beatmap.Breaks.First().EndTime));
+            AddUntilStep("activation mode is disabled", () => Player.OverlayActivationMode == OverlayActivation.Disabled);
+        }
+
+        protected override TestPlayer CreatePlayer(Ruleset ruleset) => new OverlayTestPlayer();
+
+        protected class OverlayTestPlayer : TestPlayer
+        {
+            public new OverlayActivation OverlayActivationMode => base.OverlayActivationMode.Value;
+        }
+    }
+}

osu.Game/Configuration/OsuConfigManager.cs

@@ -231,6 +231,6 @@ namespace osu.Game.Configuration
         UIHoldActivationDelay,
         HitLighting,
         MenuBackgroundSource,
-        GameplayDisableWinKey
+        GameplayDisableWinKey,
     }
 }

osu.Game/Graphics/Cursor/MenuCursorContainer.cs

@@ -5,6 +5,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Input;
+using osu.Framework.Input.StateChanges;
 
 namespace osu.Game.Graphics.Cursor
 {
@@ -47,7 +48,10 @@ namespace osu.Game.Graphics.Cursor
         {
             base.Update();
 
-            if (!CanShowCursor)
+            var lastMouseSource = inputManager.CurrentState.Mouse.LastSource;
+            bool hasValidInput = lastMouseSource != null && !(lastMouseSource is ISourcedFromTouch);
+
+            if (!hasValidInput || !CanShowCursor)
             {
                 currentTarget?.Cursor?.Hide();
                 currentTarget = null;

osu.Game/Screens/Menu/Disclaimer.cs

@@ -190,7 +190,7 @@ namespace osu.Game.Screens.Menu
             {
                 "You can press Ctrl-T anywhere in the game to toggle the toolbar!",
                 "You can press Ctrl-O anywhere in the game to access options!",
-                "All settings are dynamic and take effect in real-time. Try changing the skin while playing!",
+                "All settings are dynamic and take effect in real-time. Try pausing and changing the skin while playing!",
                 "New features are coming online every update. Make sure to stay up-to-date!",
                 "If you find the UI too large or small, try adjusting UI scale in settings!",
                 "Try adjusting the \"Screen Scaling\" mode to change your gameplay or UI area, even in fullscreen!",

osu.Game/Screens/Play/Player.cs

@@ -203,6 +203,10 @@ namespace osu.Game.Screens.Play
                 skipOverlay.Hide();
             }
 
+            DrawableRuleset.IsPaused.BindValueChanged(_ => updateOverlayActivationMode());
+            DrawableRuleset.HasReplayLoaded.BindValueChanged(_ => updateOverlayActivationMode());
+            breakTracker.IsBreakTime.BindValueChanged(_ => updateOverlayActivationMode());
+
             DrawableRuleset.HasReplayLoaded.BindValueChanged(_ => updatePauseOnFocusLostState(), true);
 
             // bind clock into components that require it
@@ -347,6 +351,16 @@ namespace osu.Game.Screens.Play
             HUDOverlay.KeyCounter.IsCounting = !isBreakTime.NewValue;
         }
 
+        private void updateOverlayActivationMode()
+        {
+            bool canTriggerOverlays = DrawableRuleset.IsPaused.Value || breakTracker.IsBreakTime.Value;
+
+            if (DrawableRuleset.HasReplayLoaded.Value || canTriggerOverlays)
+                OverlayActivationMode.Value = OverlayActivation.UserTriggered;
+            else
+                OverlayActivationMode.Value = OverlayActivation.Disabled;
+        }
+
         private void updatePauseOnFocusLostState() =>
             HUDOverlay.HoldToQuit.PauseOnFocusLost = PauseOnFocusLost
                                                      && !DrawableRuleset.HasReplayLoaded.Value
@@ -640,6 +654,8 @@ namespace osu.Game.Screens.Play
             musicController.ResetTrackAdjustments();
             foreach (var mod in Mods.Value.OfType<IApplicableToTrack>())
                 mod.ApplyToTrack(musicController.CurrentTrack);
+
+            updateOverlayActivationMode();
         }
 
         public override void OnSuspending(IScreen next)