Merge branch 'master' into stop-counting-to-score-after-fail

osu.Android.props

@@ -62,7 +62,7 @@
     <Reference Include="Java.Interop" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2019.702.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2019.731.1" />
     <PackageReference Include="ppy.osu.Framework.Android" Version="2019.807.0" />
   </ItemGroup>
 </Project>

osu.Game.Rulesets.Catch.Tests/osu.Game.Rulesets.Catch.Tests.csproj

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Rulesets.Mania.Tests/osu.Game.Rulesets.Mania.Tests.csproj

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

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

@@ -16,7 +16,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
         /// <summary>
         /// Keep the same as last row.
         /// </summary>
-        ForceStack = 1 << 0,
+        ForceStack = 1,
 
         /// <summary>
         /// Keep different from last row.

osu.Game.Rulesets.Osu.Tests/osu.Game.Rulesets.Osu.Tests.csproj

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Rulesets.Taiko.Tests/osu.Game.Rulesets.Taiko.Tests.csproj

@@ -4,7 +4,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs

@@ -482,5 +482,17 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 Assert.AreEqual(hitObjects[0].Samples[0].Bank, hitObjects[0].Samples[1].Bank);
             }
         }
+
+        [Test]
+        public void TestInvalidEventStillPasses()
+        {
+            var decoder = new LegacyBeatmapDecoder { ApplyOffsets = false };
+
+            using (var badResStream = TestResources.OpenResource("invalid-events.osu"))
+            using (var badStream = new StreamReader(badResStream))
+            {
+                Assert.DoesNotThrow(() => decoder.Decode(badStream));
+            }
+        }
     }
 }

osu.Game.Tests/Resources/invalid-events.osu

@@ -0,0 +1,14 @@
+osu file format v14
+
+[Events]
+bad,event,this,should,fail
+//Background and Video events
+0,0,"machinetop_background.jpg",0,0
+//Break Periods
+2,122474,140135
+//Storyboard Layer 0 (Background)
+this,is,also,bad
+//Storyboard Layer 1 (Fail)
+//Storyboard Layer 2 (Pass)
+//Storyboard Layer 3 (Foreground)
+//Storyboard Sound Samples

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

@@ -1,8 +1,11 @@
 // 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 NUnit.Framework;
+using osu.Framework.Timing;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Screens.Play;
 
@@ -11,78 +14,172 @@ namespace osu.Game.Tests.Visual.Gameplay
     [TestFixture]
     public class TestSceneBreakOverlay : OsuTestScene
     {
-        private readonly BreakOverlay breakOverlay;
+        public override IReadOnlyList<Type> RequiredTypes => new[]
+        {
+            typeof(BreakOverlay),
+        };
+
+        private readonly TestBreakOverlay breakOverlay;
+
+        private readonly IReadOnlyList<BreakPeriod> testBreaks = new List<BreakPeriod>
+        {
+            new BreakPeriod
+            {
+                StartTime = 1000,
+                EndTime = 5000,
+            },
+            new BreakPeriod
+            {
+                StartTime = 6000,
+                EndTime = 13500,
+            },
+        };
 
         public TestSceneBreakOverlay()
         {
-            Child = breakOverlay = new BreakOverlay(true);
+            Add(breakOverlay = new TestBreakOverlay(true));
-
-            AddStep("2s break", () => startBreak(2000));
-            AddStep("5s break", () => startBreak(5000));
-            AddStep("10s break", () => startBreak(10000));
-            AddStep("15s break", () => startBreak(15000));
-            AddStep("2s, 2s", startMultipleBreaks);
-            AddStep("0.5s, 0.7s, 1s, 2s", startAnotherMultipleBreaks);
         }
 
-        private void startBreak(double duration)
+        [Test]
+        public void TestShowBreaks()
         {
-            breakOverlay.Breaks = new List<BreakPeriod>
+            setClock(false);
+
+            addShowBreakStep(2);
+            addShowBreakStep(5);
+            addShowBreakStep(15);
+        }
+
+        [Test]
+        public void TestNoEffectsBreak()
+        {
+            var shortBreak = new BreakPeriod { EndTime = 500 };
+
+            setClock(true);
+            loadBreaksStep("short break", new[] { shortBreak });
+
+            addBreakSeeks(shortBreak, false);
+        }
+
+        [Test]
+        public void TestMultipleBreaks()
+        {
+            setClock(true);
+            loadBreaksStep("multiple breaks", testBreaks);
+
+            foreach (var b in testBreaks)
+                addBreakSeeks(b, false);
+        }
+
+        [Test]
+        public void TestRewindBreaks()
+        {
+            setClock(true);
+            loadBreaksStep("multiple breaks", testBreaks);
+
+            foreach (var b in testBreaks.Reverse())
+                addBreakSeeks(b, true);
+        }
+
+        [Test]
+        public void TestSkipBreaks()
+        {
+            setClock(true);
+            loadBreaksStep("multiple breaks", testBreaks);
+
+            seekAndAssertBreak("seek to break start", testBreaks[1].StartTime, true);
+            AddAssert("is skipped to break #2", () => breakOverlay.CurrentBreakIndex == 1);
+
+            seekAndAssertBreak("seek to break middle", testBreaks[1].StartTime + testBreaks[1].Duration / 2, true);
+            seekAndAssertBreak("seek to break end", testBreaks[1].EndTime, false);
+            seekAndAssertBreak("seek to break after end", testBreaks[1].EndTime + 500, false);
+        }
+
+        private void addShowBreakStep(double seconds)
+        {
+            AddStep($"show '{seconds}s' break", () => breakOverlay.Breaks = new List<BreakPeriod>
             {
                 new BreakPeriod
                 {
                     StartTime = Clock.CurrentTime,
-                    EndTime = Clock.CurrentTime + duration,
+                    EndTime = Clock.CurrentTime + seconds * 1000,
                 }
-            };
+            });
         }
 
-        private void startMultipleBreaks()
+        private void setClock(bool useManual)
         {
-            double currentTime = Clock.CurrentTime;
+            AddStep($"set {(useManual ? "manual" : "realtime")} clock", () => breakOverlay.SwitchClock(useManual));
-
-            breakOverlay.Breaks = new List<BreakPeriod>
-            {
-                new BreakPeriod
-                {
-                    StartTime = currentTime,
-                    EndTime = currentTime + 2000,
-                },
-                new BreakPeriod
-                {
-                    StartTime = currentTime + 4000,
-                    EndTime = currentTime + 6000,
-                }
-            };
         }
 
-        private void startAnotherMultipleBreaks()
+        private void loadBreaksStep(string breakDescription, IReadOnlyList<BreakPeriod> breaks)
         {
-            double currentTime = Clock.CurrentTime;
+            AddStep($"load {breakDescription}", () => breakOverlay.Breaks = breaks);
+            seekAndAssertBreak("seek back to 0", 0, false);
+        }
 
-            breakOverlay.Breaks = new List<BreakPeriod>
+        private void addBreakSeeks(BreakPeriod b, bool isReversed)
+        {
+            if (isReversed)
             {
-                new BreakPeriod // Duration is less than 650 - too short to appear
+                seekAndAssertBreak("seek to break after end", b.EndTime + 500, false);
-                {
+                seekAndAssertBreak("seek to break end", b.EndTime, false);
-                    StartTime = currentTime,
+                seekAndAssertBreak("seek to break middle", b.StartTime + b.Duration / 2, b.HasEffect);
-                    EndTime = currentTime + 500,
+                seekAndAssertBreak("seek to break start", b.StartTime, b.HasEffect);
-                },
+            }
-                new BreakPeriod
+            else
-                {
+            {
-                    StartTime = currentTime + 1500,
+                seekAndAssertBreak("seek to break start", b.StartTime, b.HasEffect);
-                    EndTime = currentTime + 2200,
+                seekAndAssertBreak("seek to break middle", b.StartTime + b.Duration / 2, b.HasEffect);
-                },
+                seekAndAssertBreak("seek to break end", b.EndTime, false);
-                new BreakPeriod
+                seekAndAssertBreak("seek to break after end", b.EndTime + 500, false);
-                {
+            }
-                    StartTime = currentTime + 3200,
+        }
-                    EndTime = currentTime + 4200,
+
-                },
+        private void seekAndAssertBreak(string seekStepDescription, double time, bool shouldBeBreak)
-                new BreakPeriod
+        {
-                {
+            AddStep(seekStepDescription, () => breakOverlay.ManualClockTime = time);
-                    StartTime = currentTime + 5200,
+            AddAssert($"is{(!shouldBeBreak ? " not" : string.Empty)} break time", () =>
-                    EndTime = currentTime + 7200,
+            {
-                }
+                breakOverlay.ProgressTime();
-            };
+                return breakOverlay.IsBreakTime.Value == shouldBeBreak;
+            });
+        }
+
+        private class TestBreakOverlay : BreakOverlay
+        {
+            private readonly FramedClock framedManualClock;
+            private readonly ManualClock manualClock;
+            private IFrameBasedClock originalClock;
+
+            public new int CurrentBreakIndex => base.CurrentBreakIndex;
+
+            public double ManualClockTime
+            {
+                get => manualClock.CurrentTime;
+                set => manualClock.CurrentTime = value;
+            }
+
+            public TestBreakOverlay(bool letterboxing)
+                : base(letterboxing)
+            {
+                framedManualClock = new FramedClock(manualClock = new ManualClock());
+                ProcessCustomClock = false;
+            }
+
+            public void ProgressTime()
+            {
+                framedManualClock.ProcessFrame();
+                Update();
+            }
+
+            public void SwitchClock(bool setManual) => Clock = setManual ? framedManualClock : originalClock;
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                originalClock = Clock;
+            }
         }
     }
 }

osu.Game.Tests/osu.Game.Tests.csproj

@@ -5,7 +5,7 @@
     <PackageReference Include="DeepEqual" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
     <PackageReference Update="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
   </ItemGroup>
   <PropertyGroup Label="Project">

osu.Game.Tournament.Tests/osu.Game.Tournament.Tests.csproj

@@ -7,7 +7,7 @@
     <PackageReference Include="Appveyor.TestLogger" Version="2.0.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.13.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.14.0" />
   </ItemGroup>
   <PropertyGroup Label="Project">
     <OutputType>WinExe</OutputType>

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -5,7 +5,6 @@ using System;
 using System.IO;
 using System.Linq;
 using osu.Framework.IO.File;
-using osu.Framework.Logging;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Objects.Legacy;
 using osu.Game.Beatmaps.ControlPoints;
@@ -290,8 +289,9 @@ namespace osu.Game.Beatmaps.Formats
             string[] split = line.Split(',');
 
             EventType type;
+
             if (!Enum.TryParse(split[0], out type))
-                throw new InvalidDataException($@"Unknown event type {split[0]}");
+                throw new InvalidDataException($@"Unknown event type: {split[0]}");
 
             switch (type)
             {
@@ -319,90 +319,79 @@ namespace osu.Game.Beatmaps.Formats
 
         private void handleTimingPoint(string line)
         {
-            try
+            string[] split = line.Split(',');
+
+            double time = getOffsetTime(Parsing.ParseDouble(split[0].Trim()));
+            double beatLength = Parsing.ParseDouble(split[1].Trim());
+            double speedMultiplier = beatLength < 0 ? 100.0 / -beatLength : 1;
+
+            TimeSignatures timeSignature = TimeSignatures.SimpleQuadruple;
+            if (split.Length >= 3)
+                timeSignature = split[2][0] == '0' ? TimeSignatures.SimpleQuadruple : (TimeSignatures)Parsing.ParseInt(split[2]);
+
+            LegacySampleBank sampleSet = defaultSampleBank;
+            if (split.Length >= 4)
+                sampleSet = (LegacySampleBank)Parsing.ParseInt(split[3]);
+
+            int customSampleBank = 0;
+            if (split.Length >= 5)
+                customSampleBank = Parsing.ParseInt(split[4]);
+
+            int sampleVolume = defaultSampleVolume;
+            if (split.Length >= 6)
+                sampleVolume = Parsing.ParseInt(split[5]);
+
+            bool timingChange = true;
+            if (split.Length >= 7)
+                timingChange = split[6][0] == '1';
+
+            bool kiaiMode = false;
+            bool omitFirstBarSignature = false;
+
+            if (split.Length >= 8)
             {
-                string[] split = line.Split(',');
+                EffectFlags effectFlags = (EffectFlags)Parsing.ParseInt(split[7]);
-
+                kiaiMode = effectFlags.HasFlag(EffectFlags.Kiai);
-                double time = getOffsetTime(Parsing.ParseDouble(split[0].Trim()));
+                omitFirstBarSignature = effectFlags.HasFlag(EffectFlags.OmitFirstBarLine);
-                double beatLength = Parsing.ParseDouble(split[1].Trim());
-                double speedMultiplier = beatLength < 0 ? 100.0 / -beatLength : 1;
-
-                TimeSignatures timeSignature = TimeSignatures.SimpleQuadruple;
-                if (split.Length >= 3)
-                    timeSignature = split[2][0] == '0' ? TimeSignatures.SimpleQuadruple : (TimeSignatures)Parsing.ParseInt(split[2]);
-
-                LegacySampleBank sampleSet = defaultSampleBank;
-                if (split.Length >= 4)
-                    sampleSet = (LegacySampleBank)Parsing.ParseInt(split[3]);
-
-                int customSampleBank = 0;
-                if (split.Length >= 5)
-                    customSampleBank = Parsing.ParseInt(split[4]);
-
-                int sampleVolume = defaultSampleVolume;
-                if (split.Length >= 6)
-                    sampleVolume = Parsing.ParseInt(split[5]);
-
-                bool timingChange = true;
-                if (split.Length >= 7)
-                    timingChange = split[6][0] == '1';
-
-                bool kiaiMode = false;
-                bool omitFirstBarSignature = false;
-
-                if (split.Length >= 8)
-                {
-                    EffectFlags effectFlags = (EffectFlags)Parsing.ParseInt(split[7]);
-                    kiaiMode = effectFlags.HasFlag(EffectFlags.Kiai);
-                    omitFirstBarSignature = effectFlags.HasFlag(EffectFlags.OmitFirstBarLine);
-                }
-
-                string stringSampleSet = sampleSet.ToString().ToLowerInvariant();
-                if (stringSampleSet == @"none")
-                    stringSampleSet = @"normal";
-
-                if (timingChange)
-                {
-                    var controlPoint = CreateTimingControlPoint();
-                    controlPoint.Time = time;
-                    controlPoint.BeatLength = beatLength;
-                    controlPoint.TimeSignature = timeSignature;
-
-                    handleTimingControlPoint(controlPoint);
-                }
-
-                handleDifficultyControlPoint(new DifficultyControlPoint
-                {
-                    Time = time,
-                    SpeedMultiplier = speedMultiplier,
-                    AutoGenerated = timingChange
-                });
-
-                handleEffectControlPoint(new EffectControlPoint
-                {
-                    Time = time,
-                    KiaiMode = kiaiMode,
-                    OmitFirstBarLine = omitFirstBarSignature,
-                    AutoGenerated = timingChange
-                });
-
-                handleSampleControlPoint(new LegacySampleControlPoint
-                {
-                    Time = time,
-                    SampleBank = stringSampleSet,
-                    SampleVolume = sampleVolume,
-                    CustomSampleBank = customSampleBank,
-                    AutoGenerated = timingChange
-                });
             }
-            catch (FormatException)
+
+            string stringSampleSet = sampleSet.ToString().ToLowerInvariant();
+            if (stringSampleSet == @"none")
+                stringSampleSet = @"normal";
+
+            if (timingChange)
             {
-                Logger.Log("A timing point could not be parsed correctly and will be ignored", LoggingTarget.Runtime, LogLevel.Important);
+                var controlPoint = CreateTimingControlPoint();
+                controlPoint.Time = time;
+                controlPoint.BeatLength = beatLength;
+                controlPoint.TimeSignature = timeSignature;
+
+                handleTimingControlPoint(controlPoint);
             }
-            catch (OverflowException)
+
+            handleDifficultyControlPoint(new DifficultyControlPoint
             {
-                Logger.Log("A timing point could not be parsed correctly and will be ignored", LoggingTarget.Runtime, LogLevel.Important);
+                Time = time,
-            }
+                SpeedMultiplier = speedMultiplier,
+                AutoGenerated = timingChange
+            });
+
+            handleEffectControlPoint(new EffectControlPoint
+            {
+                Time = time,
+                KiaiMode = kiaiMode,
+                OmitFirstBarLine = omitFirstBarSignature,
+                AutoGenerated = timingChange
+            });
+
+            handleSampleControlPoint(new LegacySampleControlPoint
+            {
+                Time = time,
+                SampleBank = stringSampleSet,
+                SampleVolume = sampleVolume,
+                CustomSampleBank = customSampleBank,
+                AutoGenerated = timingChange
+            });
         }
 
         private void handleTimingControlPoint(TimingControlPoint newPoint)

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -49,7 +49,7 @@ namespace osu.Game.Beatmaps.Formats
                 }
                 catch (Exception e)
                 {
-                    Logger.Error(e, $"Failed to process line \"{line}\" into {output}");
+                    Logger.Log($"Failed to process line \"{line}\" into {output}: {e.Message}", LoggingTarget.Runtime, LogLevel.Important);
                 }
             }
         }

osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs

@@ -82,8 +82,9 @@ namespace osu.Game.Beatmaps.Formats
                 storyboardSprite = null;
 
                 EventType type;
+
                 if (!Enum.TryParse(split[0], out type))
-                    throw new InvalidDataException($@"Unknown event type {split[0]}");
+                    throw new InvalidDataException($@"Unknown event type: {split[0]}");
 
                 switch (type)
                 {

osu.Game/Beatmaps/Legacy/LegacyMods.cs

@@ -9,7 +9,7 @@ namespace osu.Game.Beatmaps.Legacy
     public enum LegacyMods
     {
         None = 0,
-        NoFail = 1 << 0,
+        NoFail = 1,
         Easy = 1 << 1,
         TouchDevice = 1 << 2,
         Hidden = 1 << 3,

osu.Game/Beatmaps/Timing/BreakPeriod.cs

@@ -1,6 +1,8 @@
 // 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.Screens.Play;
+
 namespace osu.Game.Beatmaps.Timing
 {
     public class BreakPeriod
@@ -35,6 +37,6 @@ namespace osu.Game.Beatmaps.Timing
         /// </summary>
         /// <param name="time">The time to check in milliseconds.</param>
         /// <returns>Whether the time falls within this <see cref="BreakPeriod"/>.</returns>
-        public bool Contains(double time) => time >= StartTime && time <= EndTime;
+        public bool Contains(double time) => time >= StartTime && time <= EndTime - BreakOverlay.BREAK_FADE_DURATION;
     }
 }

osu.Game/Database/ArchiveModelManager.cs

@@ -31,10 +31,21 @@ namespace osu.Game.Database
     /// </summary>
     /// <typeparam name="TModel">The model type.</typeparam>
     /// <typeparam name="TFileModel">The associated file join type.</typeparam>
-    public abstract class ArchiveModelManager<TModel, TFileModel> : ArchiveModelManager, ICanAcceptFiles, IModelManager<TModel>
+    public abstract class ArchiveModelManager<TModel, TFileModel> : ICanAcceptFiles, IModelManager<TModel>
         where TModel : class, IHasFiles<TFileModel>, IHasPrimaryKey, ISoftDelete
         where TFileModel : INamedFileInfo, new()
     {
+        private const int import_queue_request_concurrency = 1;
+
+        /// <summary>
+        /// A singleton scheduler shared by all <see cref="ArchiveModelManager{TModel,TFileModel}"/>.
+        /// </summary>
+        /// <remarks>
+        /// This scheduler generally performs IO and CPU intensive work so concurrency is limited harshly.
+        /// It is mainly being used as a queue mechanism for large imports.
+        /// </remarks>
+        private static readonly ThreadedTaskScheduler import_scheduler = new ThreadedTaskScheduler(import_queue_request_concurrency, nameof(ArchiveModelManager<TModel, TFileModel>));
+
         /// <summary>
         /// Set an endpoint for notifications to be posted to.
         /// </summary>
@@ -336,7 +347,7 @@ namespace osu.Game.Database
 
             flushEvents(true);
             return item;
-        }, cancellationToken, TaskCreationOptions.HideScheduler, IMPORT_SCHEDULER).Unwrap();
+        }, cancellationToken, TaskCreationOptions.HideScheduler, import_scheduler).Unwrap();
 
         /// <summary>
         /// Perform an update of the specified item.
@@ -646,18 +657,4 @@ namespace osu.Game.Database
 
         #endregion
     }
-
-    public abstract class ArchiveModelManager
-    {
-        private const int import_queue_request_concurrency = 1;
-
-        /// <summary>
-        /// A singleton scheduler shared by all <see cref="ArchiveModelManager{TModel,TFileModel}"/>.
-        /// </summary>
-        /// <remarks>
-        /// This scheduler generally performs IO and CPU intensive work so concurrency is limited harshly.
-        /// It is mainly being used as a queue mechanism for large imports.
-        /// </remarks>
-        protected static readonly ThreadedTaskScheduler IMPORT_SCHEDULER = new ThreadedTaskScheduler(import_queue_request_concurrency, nameof(ArchiveModelManager));
-    }
 }

osu.Game/Graphics/UserInterface/Bar.cs

@@ -110,7 +110,7 @@ namespace osu.Game.Graphics.UserInterface
     [Flags]
     public enum BarDirection
     {
-        LeftToRight = 1 << 0,
+        LeftToRight = 1,
         RightToLeft = 1 << 1,
         TopToBottom = 1 << 2,
         BottomToTop = 1 << 3,

osu.Game/Online/Chat/ChannelManager.cs

@@ -213,8 +213,27 @@ namespace osu.Game.Online.Chat
                     PostMessage(content, true);
                     break;
 
+                case "join":
+                    if (string.IsNullOrWhiteSpace(content))
+                    {
+                        target.AddNewMessages(new ErrorMessage("Usage: /join [channel]"));
+                        break;
+                    }
+
+                    var channel = availableChannels.Where(c => c.Name == content || c.Name == $"#{content}").FirstOrDefault();
+
+                    if (channel == null)
+                    {
+                        target.AddNewMessages(new ErrorMessage($"Channel '{content}' not found."));
+                        break;
+                    }
+
+                    JoinChannel(channel);
+                    CurrentChannel.Value = channel;
+                    break;
+
                 case "help":
-                    target.AddNewMessages(new InfoMessage("Supported commands: /help, /me [action]"));
+                    target.AddNewMessages(new InfoMessage("Supported commands: /help, /me [action], /join [channel]"));
                     break;
 
                 default:

osu.Game/Online/Chat/ErrorMessage.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Online.Chat
         public ErrorMessage(string message)
             : base(message)
         {
-            Sender.Colour = @"ff0000";
+            // todo: this should likely be styled differently in the future.
         }
     }
 }

osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectParser.cs

@@ -10,7 +10,6 @@ using osu.Game.Beatmaps.Formats;
 using osu.Game.Audio;
 using System.Linq;
 using JetBrains.Annotations;
-using osu.Framework.Logging;
 using osu.Framework.MathUtils;
 
 namespace osu.Game.Rulesets.Objects.Legacy
@@ -41,208 +40,192 @@ namespace osu.Game.Rulesets.Objects.Legacy
         [CanBeNull]
         public override HitObject Parse(string text)
         {
-            try
+            string[] split = text.Split(',');
+
+            Vector2 pos = new Vector2((int)Parsing.ParseFloat(split[0], Parsing.MAX_COORDINATE_VALUE), (int)Parsing.ParseFloat(split[1], Parsing.MAX_COORDINATE_VALUE));
+
+            double startTime = Parsing.ParseDouble(split[2]) + Offset;
+
+            ConvertHitObjectType type = (ConvertHitObjectType)Parsing.ParseInt(split[3]);
+
+            int comboOffset = (int)(type & ConvertHitObjectType.ComboOffset) >> 4;
+            type &= ~ConvertHitObjectType.ComboOffset;
+
+            bool combo = type.HasFlag(ConvertHitObjectType.NewCombo);
+            type &= ~ConvertHitObjectType.NewCombo;
+
+            var soundType = (LegacySoundType)Parsing.ParseInt(split[4]);
+            var bankInfo = new SampleBankInfo();
+
+            HitObject result = null;
+
+            if (type.HasFlag(ConvertHitObjectType.Circle))
             {
-                string[] split = text.Split(',');
+                result = CreateHit(pos, combo, comboOffset);
 
-                Vector2 pos = new Vector2((int)Parsing.ParseFloat(split[0], Parsing.MAX_COORDINATE_VALUE), (int)Parsing.ParseFloat(split[1], Parsing.MAX_COORDINATE_VALUE));
+                if (split.Length > 5)
+                    readCustomSampleBanks(split[5], bankInfo);
+            }
+            else if (type.HasFlag(ConvertHitObjectType.Slider))
+            {
+                PathType pathType = PathType.Catmull;
+                double? length = null;
 
-                double startTime = Parsing.ParseDouble(split[2]) + Offset;
+                string[] pointSplit = split[5].Split('|');
 
-                ConvertHitObjectType type = (ConvertHitObjectType)Parsing.ParseInt(split[3]);
+                int pointCount = 1;
+                foreach (var t in pointSplit)
+                    if (t.Length > 1)
+                        pointCount++;
 
-                int comboOffset = (int)(type & ConvertHitObjectType.ComboOffset) >> 4;
+                var points = new Vector2[pointCount];
-                type &= ~ConvertHitObjectType.ComboOffset;
 
-                bool combo = type.HasFlag(ConvertHitObjectType.NewCombo);
+                int pointIndex = 1;
-                type &= ~ConvertHitObjectType.NewCombo;
 
-                var soundType = (LegacySoundType)Parsing.ParseInt(split[4]);
+                foreach (string t in pointSplit)
-                var bankInfo = new SampleBankInfo();
-
-                HitObject result = null;
-
-                if (type.HasFlag(ConvertHitObjectType.Circle))
                 {
-                    result = CreateHit(pos, combo, comboOffset);
+                    if (t.Length == 1)
-
-                    if (split.Length > 5)
-                        readCustomSampleBanks(split[5], bankInfo);
-                }
-                else if (type.HasFlag(ConvertHitObjectType.Slider))
-                {
-                    PathType pathType = PathType.Catmull;
-                    double? length = null;
-
-                    string[] pointSplit = split[5].Split('|');
-
-                    int pointCount = 1;
-                    foreach (var t in pointSplit)
-                        if (t.Length > 1)
-                            pointCount++;
-
-                    var points = new Vector2[pointCount];
-
-                    int pointIndex = 1;
-
-                    foreach (string t in pointSplit)
                     {
-                        if (t.Length == 1)
+                        switch (t)
                         {
-                            switch (t)
+                            case @"C":
-                            {
+                                pathType = PathType.Catmull;
-                                case @"C":
-                                    pathType = PathType.Catmull;
-                                    break;
-
-                                case @"B":
-                                    pathType = PathType.Bezier;
-                                    break;
-
-                                case @"L":
-                                    pathType = PathType.Linear;
-                                    break;
-
-                                case @"P":
-                                    pathType = PathType.PerfectCurve;
-                                    break;
-                            }
-
-                            continue;
-                        }
-
-                        string[] temp = t.Split(':');
-                        points[pointIndex++] = new Vector2((int)Parsing.ParseDouble(temp[0], Parsing.MAX_COORDINATE_VALUE), (int)Parsing.ParseDouble(temp[1], Parsing.MAX_COORDINATE_VALUE)) - pos;
-                    }
-
-                    // osu-stable special-cased colinear perfect curves to a CurveType.Linear
-                    bool isLinear(Vector2[] p) => Precision.AlmostEquals(0, (p[1].Y - p[0].Y) * (p[2].X - p[0].X) - (p[1].X - p[0].X) * (p[2].Y - p[0].Y));
-
-                    if (points.Length == 3 && pathType == PathType.PerfectCurve && isLinear(points))
-                        pathType = PathType.Linear;
-
-                    int repeatCount = Parsing.ParseInt(split[6]);
-
-                    if (repeatCount > 9000)
-                        throw new ArgumentOutOfRangeException(nameof(repeatCount), @"Repeat count is way too high");
-
-                    // osu-stable treated the first span of the slider as a repeat, but no repeats are happening
-                    repeatCount = Math.Max(0, repeatCount - 1);
-
-                    if (split.Length > 7)
-                    {
-                        length = Math.Max(0, Parsing.ParseDouble(split[7]));
-                        if (length == 0)
-                            length = null;
-                    }
-
-                    if (split.Length > 10)
-                        readCustomSampleBanks(split[10], bankInfo);
-
-                    // One node for each repeat + the start and end nodes
-                    int nodes = repeatCount + 2;
-
-                    // Populate node sample bank infos with the default hit object sample bank
-                    var nodeBankInfos = new List<SampleBankInfo>();
-                    for (int i = 0; i < nodes; i++)
-                        nodeBankInfos.Add(bankInfo.Clone());
-
-                    // Read any per-node sample banks
-                    if (split.Length > 9 && split[9].Length > 0)
-                    {
-                        string[] sets = split[9].Split('|');
-
-                        for (int i = 0; i < nodes; i++)
-                        {
-                            if (i >= sets.Length)
                                 break;
 
-                            SampleBankInfo info = nodeBankInfos[i];
+                            case @"B":
-                            readCustomSampleBanks(sets[i], info);
+                                pathType = PathType.Bezier;
-                        }
-                    }
-
-                    // Populate node sound types with the default hit object sound type
-                    var nodeSoundTypes = new List<LegacySoundType>();
-                    for (int i = 0; i < nodes; i++)
-                        nodeSoundTypes.Add(soundType);
-
-                    // Read any per-node sound types
-                    if (split.Length > 8 && split[8].Length > 0)
-                    {
-                        string[] adds = split[8].Split('|');
-
-                        for (int i = 0; i < nodes; i++)
-                        {
-                            if (i >= adds.Length)
                                 break;
 
-                            int sound;
+                            case @"L":
-                            int.TryParse(adds[i], out sound);
+                                pathType = PathType.Linear;
-                            nodeSoundTypes[i] = (LegacySoundType)sound;
+                                break;
+
+                            case @"P":
+                                pathType = PathType.PerfectCurve;
+                                break;
                         }
+
+                        continue;
                     }
 
-                    // Generate the final per-node samples
+                    string[] temp = t.Split(':');
-                    var nodeSamples = new List<List<HitSampleInfo>>(nodes);
+                    points[pointIndex++] = new Vector2((int)Parsing.ParseDouble(temp[0], Parsing.MAX_COORDINATE_VALUE), (int)Parsing.ParseDouble(temp[1], Parsing.MAX_COORDINATE_VALUE)) - pos;
+                }
+
+                // osu-stable special-cased colinear perfect curves to a CurveType.Linear
+                bool isLinear(Vector2[] p) => Precision.AlmostEquals(0, (p[1].Y - p[0].Y) * (p[2].X - p[0].X) - (p[1].X - p[0].X) * (p[2].Y - p[0].Y));
+
+                if (points.Length == 3 && pathType == PathType.PerfectCurve && isLinear(points))
+                    pathType = PathType.Linear;
+
+                int repeatCount = Parsing.ParseInt(split[6]);
+
+                if (repeatCount > 9000)
+                    throw new ArgumentOutOfRangeException(nameof(repeatCount), @"Repeat count is way too high");
+
+                // osu-stable treated the first span of the slider as a repeat, but no repeats are happening
+                repeatCount = Math.Max(0, repeatCount - 1);
+
+                if (split.Length > 7)
+                {
+                    length = Math.Max(0, Parsing.ParseDouble(split[7]));
+                    if (length == 0)
+                        length = null;
+                }
+
+                if (split.Length > 10)
+                    readCustomSampleBanks(split[10], bankInfo);
+
+                // One node for each repeat + the start and end nodes
+                int nodes = repeatCount + 2;
+
+                // Populate node sample bank infos with the default hit object sample bank
+                var nodeBankInfos = new List<SampleBankInfo>();
+                for (int i = 0; i < nodes; i++)
+                    nodeBankInfos.Add(bankInfo.Clone());
+
+                // Read any per-node sample banks
+                if (split.Length > 9 && split[9].Length > 0)
+                {
+                    string[] sets = split[9].Split('|');
+
                     for (int i = 0; i < nodes; i++)
-                        nodeSamples.Add(convertSoundType(nodeSoundTypes[i], nodeBankInfos[i]));
-
-                    result = CreateSlider(pos, combo, comboOffset, points, length, pathType, repeatCount, nodeSamples);
-
-                    // The samples are played when the slider ends, which is the last node
-                    result.Samples = nodeSamples[nodeSamples.Count - 1];
-                }
-                else if (type.HasFlag(ConvertHitObjectType.Spinner))
-                {
-                    double endTime = Math.Max(startTime, Parsing.ParseDouble(split[5]) + Offset);
-
-                    result = CreateSpinner(new Vector2(512, 384) / 2, combo, comboOffset, endTime);
-
-                    if (split.Length > 6)
-                        readCustomSampleBanks(split[6], bankInfo);
-                }
-                else if (type.HasFlag(ConvertHitObjectType.Hold))
-                {
-                    // Note: Hold is generated by BMS converts
-
-                    double endTime = Math.Max(startTime, Parsing.ParseDouble(split[2]));
-
-                    if (split.Length > 5 && !string.IsNullOrEmpty(split[5]))
                     {
-                        string[] ss = split[5].Split(':');
+                        if (i >= sets.Length)
-                        endTime = Math.Max(startTime, Parsing.ParseDouble(ss[0]));
+                            break;
-                        readCustomSampleBanks(string.Join(":", ss.Skip(1)), bankInfo);
+
+                        SampleBankInfo info = nodeBankInfos[i];
+                        readCustomSampleBanks(sets[i], info);
                     }
-
-                    result = CreateHold(pos, combo, comboOffset, endTime + Offset);
                 }
 
-                if (result == null)
+                // Populate node sound types with the default hit object sound type
+                var nodeSoundTypes = new List<LegacySoundType>();
+                for (int i = 0; i < nodes; i++)
+                    nodeSoundTypes.Add(soundType);
+
+                // Read any per-node sound types
+                if (split.Length > 8 && split[8].Length > 0)
                 {
-                    Logger.Log($"Unknown hit object type: {type}. Skipped.", level: LogLevel.Error);
+                    string[] adds = split[8].Split('|');
-                    return null;
+
+                    for (int i = 0; i < nodes; i++)
+                    {
+                        if (i >= adds.Length)
+                            break;
+
+                        int sound;
+                        int.TryParse(adds[i], out sound);
+                        nodeSoundTypes[i] = (LegacySoundType)sound;
+                    }
                 }
 
-                result.StartTime = startTime;
+                // Generate the final per-node samples
+                var nodeSamples = new List<List<HitSampleInfo>>(nodes);
+                for (int i = 0; i < nodes; i++)
+                    nodeSamples.Add(convertSoundType(nodeSoundTypes[i], nodeBankInfos[i]));
 
-                if (result.Samples.Count == 0)
+                result = CreateSlider(pos, combo, comboOffset, points, length, pathType, repeatCount, nodeSamples);
-                    result.Samples = convertSoundType(soundType, bankInfo);
 
-                FirstObject = false;
+                // The samples are played when the slider ends, which is the last node
-
+                result.Samples = nodeSamples[nodeSamples.Count - 1];
-                return result;
             }
-            catch (FormatException)
+            else if (type.HasFlag(ConvertHitObjectType.Spinner))
             {
-                Logger.Log("A hitobject could not be parsed correctly and will be ignored", LoggingTarget.Runtime, LogLevel.Important);
+                double endTime = Math.Max(startTime, Parsing.ParseDouble(split[5]) + Offset);
+
+                result = CreateSpinner(new Vector2(512, 384) / 2, combo, comboOffset, endTime);
+
+                if (split.Length > 6)
+                    readCustomSampleBanks(split[6], bankInfo);
             }
-            catch (OverflowException)
+            else if (type.HasFlag(ConvertHitObjectType.Hold))
             {
-                Logger.Log("A hitobject could not be parsed correctly and will be ignored", LoggingTarget.Runtime, LogLevel.Important);
+                // Note: Hold is generated by BMS converts
+
+                double endTime = Math.Max(startTime, Parsing.ParseDouble(split[2]));
+
+                if (split.Length > 5 && !string.IsNullOrEmpty(split[5]))
+                {
+                    string[] ss = split[5].Split(':');
+                    endTime = Math.Max(startTime, Parsing.ParseDouble(ss[0]));
+                    readCustomSampleBanks(string.Join(":", ss.Skip(1)), bankInfo);
+                }
+
+                result = CreateHold(pos, combo, comboOffset, endTime + Offset);
             }
 
-            return null;
+            if (result == null)
+                throw new InvalidDataException($"Unknown hit object type: {split[3]}");
+
+            result.StartTime = startTime;
+
+            if (result.Samples.Count == 0)
+                result.Samples = convertSoundType(soundType, bankInfo);
+
+            FirstObject = false;
+
+            return result;
         }
 
         private void readCustomSampleBanks(string str, SampleBankInfo bankInfo)

osu.Game/Rulesets/Objects/Legacy/ConvertHitObjectType.cs

@@ -8,7 +8,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
     [Flags]
     internal enum ConvertHitObjectType
     {
-        Circle = 1 << 0,
+        Circle = 1,
         Slider = 1 << 1,
         NewCombo = 1 << 2,
         Spinner = 1 << 3,

osu.Game/Rulesets/Scoring/ScoreProcessor.cs

@@ -313,6 +313,9 @@ namespace osu.Game.Rulesets.Scoring
         /// <summary>
         /// Applies the score change of a <see cref="JudgementResult"/> to this <see cref="ScoreProcessor"/>.
         /// </summary>
+        /// <remarks>
+        /// Any changes applied via this method can be reverted via <see cref="RevertResult"/>.
+        /// </remarks>
         /// <param name="result">The <see cref="JudgementResult"/> to apply.</param>
         protected virtual void ApplyResult(JudgementResult result)
         {
@@ -361,7 +364,7 @@ namespace osu.Game.Rulesets.Scoring
         }
 
         /// <summary>
-        /// Reverts the score change of a <see cref="JudgementResult"/> that was applied to this <see cref="ScoreProcessor"/>.
+        /// Reverts the score change of a <see cref="JudgementResult"/> that was applied to this <see cref="ScoreProcessor"/> via <see cref="ApplyResult"/>.
         /// </summary>
         /// <param name="result">The judgement scoring result.</param>
         protected virtual void RevertResult(JudgementResult result)

osu.Game/Screens/Direct/OnlineListing.cs

@@ -1,9 +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.
-
-namespace osu.Game.Screens.Direct
-{
-    public class OnlineListing : ScreenWhiteBox
-    {
-    }
-}

osu.Game/Screens/Menu/MainMenu.cs

@@ -14,7 +14,6 @@ using osu.Game.Graphics.Containers;
 using osu.Game.Overlays;
 using osu.Game.Screens.Backgrounds;
 using osu.Game.Screens.Charts;
-using osu.Game.Screens.Direct;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Multi;
 using osu.Game.Screens.Select;
@@ -65,7 +64,6 @@ namespace osu.Game.Screens.Menu
                         buttons = new ButtonSystem
                         {
                             OnChart = delegate { this.Push(new ChartListing()); },
-                            OnDirect = delegate { this.Push(new OnlineListing()); },
                             OnEdit = delegate { this.Push(new Editor()); },
                             OnSolo = onSolo,
                             OnMulti = delegate { this.Push(new Multiplayer()); },

osu.Game/Screens/Play/BreakOverlay.cs

@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using osu.Framework.Allocation;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -15,7 +16,11 @@ namespace osu.Game.Screens.Play
 {
     public class BreakOverlay : Container
     {
-        private const double fade_duration = BreakPeriod.MIN_BREAK_DURATION / 2;
+        /// <summary>
+        /// The duration of the break overlay fading.
+        /// </summary>
+        public const double BREAK_FADE_DURATION = BreakPeriod.MIN_BREAK_DURATION / 2;
+
         private const float remaining_time_container_max_size = 0.3f;
         private const int vertical_margin = 25;
 
@@ -29,12 +34,27 @@ namespace osu.Game.Screens.Play
             set
             {
                 breaks = value;
-                initializeBreaks();
+
+                // reset index in case the new breaks list is smaller than last one
+                isBreakTime.Value = false;
+                CurrentBreakIndex = 0;
+
+                if (IsLoaded)
+                    initializeBreaks();
             }
         }
 
         public override bool RemoveCompletedTransforms => false;
 
+        /// <summary>
+        /// Whether the gameplay is currently in a break.
+        /// </summary>
+        public IBindable<bool> IsBreakTime => isBreakTime;
+
+        protected int CurrentBreakIndex;
+
+        private readonly BindableBool isBreakTime = new BindableBool();
+
         private readonly Container remainingTimeAdjustmentBox;
         private readonly Container remainingTimeBox;
         private readonly RemainingTimeCounter remainingTimeCounter;
@@ -109,10 +129,36 @@ namespace osu.Game.Screens.Play
             initializeBreaks();
         }
 
+        protected override void Update()
+        {
+            base.Update();
+            updateBreakTimeBindable();
+        }
+
+        private void updateBreakTimeBindable()
+        {
+            if (breaks == null || breaks.Count == 0)
+                return;
+
+            var time = Clock.CurrentTime;
+
+            if (time > breaks[CurrentBreakIndex].EndTime)
+            {
+                while (time > breaks[CurrentBreakIndex].EndTime && CurrentBreakIndex < breaks.Count - 1)
+                    CurrentBreakIndex++;
+            }
+            else
+            {
+                while (time < breaks[CurrentBreakIndex].StartTime && CurrentBreakIndex > 0)
+                    CurrentBreakIndex--;
+            }
+
+            var currentBreak = breaks[CurrentBreakIndex];
+            isBreakTime.Value = currentBreak.HasEffect && currentBreak.Contains(time);
+        }
+
         private void initializeBreaks()
         {
-            if (!IsLoaded) return; // we need a clock.
-
             FinishTransforms(true);
             Scheduler.CancelDelayedTasks();
 
@@ -125,25 +171,25 @@ namespace osu.Game.Screens.Play
 
                 using (BeginAbsoluteSequence(b.StartTime, true))
                 {
-                    fadeContainer.FadeIn(fade_duration);
+                    fadeContainer.FadeIn(BREAK_FADE_DURATION);
-                    breakArrows.Show(fade_duration);
+                    breakArrows.Show(BREAK_FADE_DURATION);
 
                     remainingTimeAdjustmentBox
-                        .ResizeWidthTo(remaining_time_container_max_size, fade_duration, Easing.OutQuint)
+                        .ResizeWidthTo(remaining_time_container_max_size, BREAK_FADE_DURATION, Easing.OutQuint)
-                        .Delay(b.Duration - fade_duration)
+                        .Delay(b.Duration - BREAK_FADE_DURATION)
                         .ResizeWidthTo(0);
 
                     remainingTimeBox
-                        .ResizeWidthTo(0, b.Duration - fade_duration)
+                        .ResizeWidthTo(0, b.Duration - BREAK_FADE_DURATION)
                         .Then()
                         .ResizeWidthTo(1);
 
                     remainingTimeCounter.CountTo(b.Duration).CountTo(0, b.Duration);
 
-                    using (BeginDelayedSequence(b.Duration - fade_duration, true))
+                    using (BeginDelayedSequence(b.Duration - BREAK_FADE_DURATION, true))
                     {
-                        fadeContainer.FadeOut(fade_duration);
+                        fadeContainer.FadeOut(BREAK_FADE_DURATION);
-                        breakArrows.Hide(fade_duration);
+                        breakArrows.Hide(BREAK_FADE_DURATION);
                     }
                 }
             }

osu.Game/Screens/Play/Player.cs

@@ -66,6 +66,8 @@ namespace osu.Game.Screens.Play
 
         private SampleChannel sampleRestart;
 
+        private BreakOverlay breakOverlay;
+
         protected ScoreProcessor ScoreProcessor { get; private set; }
         protected DrawableRuleset DrawableRuleset { get; private set; }
 
@@ -134,7 +136,7 @@ namespace osu.Game.Screens.Play
                         }
                     }
                 },
-                new BreakOverlay(working.Beatmap.BeatmapInfo.LetterboxInBreaks, ScoreProcessor)
+                breakOverlay = new BreakOverlay(working.Beatmap.BeatmapInfo.LetterboxInBreaks, ScoreProcessor)
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
@@ -411,8 +413,7 @@ namespace osu.Game.Screens.Play
             PauseOverlay.Hide();
 
             // breaks and time-based conditions may allow instant resume.
-            double time = GameplayClockContainer.GameplayClock.CurrentTime;
+            if (breakOverlay.IsBreakTime.Value || GameplayClockContainer.GameplayClock.CurrentTime < Beatmap.Value.Beatmap.HitObjects.First().StartTime)
-            if (Beatmap.Value.Beatmap.Breaks.Any(b => b.Contains(time)) || time < Beatmap.Value.Beatmap.HitObjects.First().StartTime)
                 completeResume();
             else
                 DrawableRuleset.RequestResume(completeResume);

osu.Game/Users/User.cs

@@ -187,6 +187,7 @@ namespace osu.Game.Users
         public static readonly User SYSTEM_USER = new User
         {
             Username = "system",
+            Colour = @"9c0101",
             Id = 0
         };
 

osu.Game/osu.Game.csproj

@@ -14,7 +14,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.6" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.6" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2019.702.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2019.731.1" />
     <PackageReference Include="ppy.osu.Framework" Version="2019.807.0" />
     <PackageReference Include="SharpCompress" Version="0.23.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />

osu.iOS.props

@@ -104,7 +104,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.1" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.2.1" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
-    <PackageReference Include="ppy.osu.Game.Resources" Version="2019.702.0" />
+    <PackageReference Include="ppy.osu.Game.Resources" Version="2019.731.1" />
     <PackageReference Include="ppy.osu.Framework" Version="2019.807.0" />
     <PackageReference Include="ppy.osu.Framework.iOS" Version="2019.807.0" />
     <PackageReference Include="SharpCompress" Version="0.22.0" />