Merge pull request #3287 from smoogipoo/no-objects-logging

Soft-handle errors when beatmap contains no objects

osu.Desktop/Program.cs

@@ -63,7 +63,7 @@ namespace osu.Desktop
         {
             bool continueExecution = Interlocked.Decrement(ref allowableExceptions) >= 0;
 
-            Logger.Log($"Unhandled exception has been {(continueExecution ? "allowed with {allowableExceptions} more allowable exceptions" : "denied")} .");
+            Logger.Log($"Unhandled exception has been {(continueExecution ? $"allowed with {allowableExceptions} more allowable exceptions" : "denied")} .");
 
             // restore the stock of allowable exceptions after a short delay.
             Task.Delay(1000).ContinueWith(_ => Interlocked.Increment(ref allowableExceptions));

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

@@ -0,0 +1,64 @@
+// 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.IO;
+using System.Linq;
+using System.Text;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Tests.Beatmaps;
+using Decoder = osu.Game.Beatmaps.Formats.Decoder;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    [TestFixture]
+    public class StackingTest
+    {
+        [Test]
+        public void TestStacking()
+        {
+            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(beatmap_data)))
+            using (var reader = new StreamReader(stream))
+            {
+                var beatmap = Decoder.GetDecoder<Beatmap>(reader).Decode(reader);
+                var converted = new TestWorkingBeatmap(beatmap).GetPlayableBeatmap(new OsuRuleset().RulesetInfo);
+
+                var objects = converted.HitObjects.ToList();
+
+                // The last hitobject triggers the stacking
+                for (int i = 0; i < objects.Count - 1; i++)
+                    Assert.AreEqual(0, ((OsuHitObject)objects[i]).StackHeight);
+            }
+        }
+
+        private const string beatmap_data = @"
+osu file format v14
+
+[General]
+StackLeniency: 0.2
+
+[Difficulty]
+ApproachRate:9.2
+SliderMultiplier:1
+SliderTickRate:0.5
+
+[TimingPoints]
+217871,6400,4,2,1,20,1,0
+217871,-800,4,2,1,20,0,0
+218071,-787.5,4,2,1,20,0,0
+218271,-775,4,2,1,20,0,0
+218471,-762.5,4,2,1,20,0,0
+218671,-750,4,2,1,20,0,0
+240271,-10,4,2,0,5,0,0
+
+[HitObjects]
+311,185,217871,6,0,L|318:158,1,25
+311,185,218071,2,0,L|335:170,1,25
+311,185,218271,2,0,L|338:192,1,25
+311,185,218471,2,0,L|325:209,1,25
+311,185,218671,2,0,L|304:212,1,25
+311,185,240271,5,0,0:0:0:0:
+";
+    }
+}

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs

@@ -15,9 +15,9 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
         {
         }
 
-        public override void PreProcess()
+        public override void PostProcess()
         {
-            base.PreProcess();
+            base.PostProcess();
             applyStacking((Beatmap<OsuHitObject>)Beatmap);
         }
 

osu.Game.Rulesets.Osu/Mods/OsuModRelax.cs

@@ -2,14 +2,89 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Input.States;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+using static osu.Game.Input.Handlers.ReplayInputHandler;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModRelax : ModRelax
+    public class OsuModRelax : ModRelax, IApplicableFailOverride, IUpdatableByPlayfield, IApplicableToRulesetContainer<OsuHitObject>
     {
         public override string Description => @"You don't need to click. Give your clicking/tapping fingers a break from the heat of things.";
         public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModAutopilot)).ToArray();
+
+        public bool AllowFail => false;
+
+        public void Update(Playfield playfield)
+        {
+            bool requiresHold = false;
+            bool requiresHit = false;
+
+            const float relax_leniency = 3;
+
+            foreach (var drawable in playfield.HitObjects.AliveObjects)
+            {
+                if (!(drawable is DrawableOsuHitObject osuHit))
+                    continue;
+
+                double time = osuHit.Clock.CurrentTime;
+                double relativetime = time - osuHit.HitObject.StartTime;
+
+                if (time < osuHit.HitObject.StartTime - relax_leniency) continue;
+
+                if (osuHit.HitObject is IHasEndTime hasEnd && time > hasEnd.EndTime || osuHit.IsHit)
+                    continue;
+
+                requiresHit |= osuHit is DrawableHitCircle && osuHit.IsHovered && osuHit.HitObject.HitWindows.CanBeHit(relativetime);
+                requiresHold |= osuHit is DrawableSlider slider && (slider.Ball.IsHovered || osuHit.IsHovered) || osuHit is DrawableSpinner;
+            }
+
+            if (requiresHit)
+            {
+                addAction(false);
+                addAction(true);
+            }
+
+            addAction(requiresHold);
+        }
+
+        private bool wasHit;
+        private bool wasLeft;
+
+        private OsuInputManager osuInputManager;
+
+        private void addAction(bool hitting)
+        {
+            if (wasHit == hitting)
+                return;
+
+            wasHit = hitting;
+
+            var state = new ReplayState<OsuAction>
+            {
+                PressedActions = new List<OsuAction>()
+            };
+
+            if (hitting)
+            {
+                state.PressedActions.Add(wasLeft ? OsuAction.LeftButton : OsuAction.RightButton);
+                wasLeft = !wasLeft;
+            }
+
+            osuInputManager.HandleCustomInput(new InputState(), state);
+        }
+
+        public void ApplyToRulesetContainer(RulesetContainer<OsuHitObject> rulesetContainer)
+        {
+            // grab the input manager for future use.
+            osuInputManager = (OsuInputManager)rulesetContainer.KeyBindingInputManager;
+            osuInputManager.AllowUserPresses = false;
+        }
     }
 }

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SliderBall.cs

@@ -8,7 +8,6 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.EventArgs;
 using osu.Framework.Input.States;
 using osu.Game.Rulesets.Objects.Types;
-using OpenTK;
 using OpenTK.Graphics;
 using osu.Game.Skinning;
 
@@ -121,9 +120,6 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
             return base.OnMouseMove(state);
         }
 
-        // If the current time is between the start and end of the slider, we should track mouse input regardless of the cursor position.
-        public override bool ReceiveMouseInputAt(Vector2 screenSpacePos) => canCurrentlyTrack || base.ReceiveMouseInputAt(screenSpacePos);
-
         public override void ClearTransformsAfter(double time, bool propagateChildren = false, string targetMember = null)
         {
             // Consider the case of rewinding - children's transforms are handled internally, so propagating down
@@ -158,7 +154,7 @@ namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
                 // Make sure to use the base version of ReceiveMouseInputAt so that we correctly check the position.
                 Tracking = canCurrentlyTrack
                            && lastState != null
-                           && base.ReceiveMouseInputAt(lastState.Mouse.NativeState.Position)
+                           && ReceiveMouseInputAt(lastState.Mouse.NativeState.Position)
                            && ((Parent as DrawableSlider)?.OsuActionInputManager?.PressedActions.Any(x => x == OsuAction.LeftButton || x == OsuAction.RightButton) ?? false);
             }
         }

osu.Game.Rulesets.Osu/OsuInputManager.cs

@@ -4,6 +4,8 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using osu.Framework.Input.Bindings;
+using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.States;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Osu
@@ -12,8 +14,35 @@ namespace osu.Game.Rulesets.Osu
     {
         public IEnumerable<OsuAction> PressedActions => KeyBindingContainer.PressedActions;
 
-        public OsuInputManager(RulesetInfo ruleset) : base(ruleset, 0, SimultaneousBindingMode.Unique)
+        public bool AllowUserPresses
         {
+            set => ((OsuKeyBindingContainer)KeyBindingContainer).AllowUserPresses = value;
+        }
+
+        protected override RulesetKeyBindingContainer CreateKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+            => new OsuKeyBindingContainer(ruleset, variant, unique);
+
+        public OsuInputManager(RulesetInfo ruleset)
+            : base(ruleset, 0, SimultaneousBindingMode.Unique)
+        {
+        }
+
+        private class OsuKeyBindingContainer : RulesetKeyBindingContainer
+        {
+            public bool AllowUserPresses = true;
+
+            public OsuKeyBindingContainer(RulesetInfo ruleset, int variant, SimultaneousBindingMode unique)
+                : base(ruleset, variant, unique)
+            {
+            }
+
+            protected override bool OnKeyDown(InputState state, KeyDownEventArgs args) => AllowUserPresses && base.OnKeyDown(state, args);
+            protected override bool OnKeyUp(InputState state, KeyUpEventArgs args) => AllowUserPresses && base.OnKeyUp(state, args);
+            protected override bool OnJoystickPress(InputState state, JoystickEventArgs args) => AllowUserPresses && base.OnJoystickPress(state, args);
+            protected override bool OnJoystickRelease(InputState state, JoystickEventArgs args) => AllowUserPresses && base.OnJoystickRelease(state, args);
+            protected override bool OnMouseDown(InputState state, MouseDownEventArgs args) => AllowUserPresses && base.OnMouseDown(state, args);
+            protected override bool OnMouseUp(InputState state, MouseUpEventArgs args) => AllowUserPresses && base.OnMouseUp(state, args);
+            protected override bool OnScroll(InputState state) => AllowUserPresses && base.OnScroll(state);
         }
     }
 
@@ -21,6 +50,7 @@ namespace osu.Game.Rulesets.Osu
     {
         [Description("Left Button")]
         LeftButton,
+
         [Description("Right Button")]
         RightButton
     }

osu.Game.Rulesets.Taiko/Beatmaps/TaikoBeatmapConverter.cs

@@ -62,7 +62,7 @@ namespace osu.Game.Rulesets.Taiko.Beatmaps
                 converted.HitObjects = converted.HitObjects.GroupBy(t => t.StartTime).Select(x =>
                 {
                     TaikoHitObject first = x.First();
-                    if (x.Skip(1).Any())
+                    if (x.Skip(1).Any() && !(first is Swell))
                         first.IsStrong = true;
                     return first;
                 }).ToList();

osu.Game/Beatmaps/BeatmapManager.cs

@@ -350,7 +350,8 @@ namespace osu.Game.Beatmaps
         {
             // let's make sure there are actually .osu files to import.
             string mapName = reader.Filenames.FirstOrDefault(f => f.EndsWith(".osu"));
-            if (string.IsNullOrEmpty(mapName)) throw new InvalidOperationException("No beatmap files found in this beatmap archive.");
+            if (string.IsNullOrEmpty(mapName))
+                throw new InvalidOperationException($"No beatmap files found in this beatmap archive ({reader.Name}).");
 
             Beatmap beatmap;
             using (var stream = new StreamReader(reader.GetStream(mapName)))

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -408,11 +408,8 @@ namespace osu.Game.Beatmaps.Formats
                 parser = new Rulesets.Objects.Legacy.Osu.ConvertHitObjectParser(getOffsetTime(), FormatVersion);
 
             var obj = parser.Parse(line);
-
             if (obj != null)
-            {
                 beatmap.HitObjects.Add(obj);
-            }
         }
 
         private int getOffsetTime(int time) => time + (ApplyOffsets ? offset : 0);

osu.Game/Beatmaps/Formats/LegacyDecoder.cs

@@ -31,7 +31,7 @@ namespace osu.Game.Beatmaps.Formats
                 if (ShouldSkipLine(line))
                     continue;
 
-                if (line.StartsWith(@"[") && line.EndsWith(@"]"))
+                if (line.StartsWith(@"[", StringComparison.Ordinal) && line.EndsWith(@"]", StringComparison.Ordinal))
                 {
                     if (!Enum.TryParse(line.Substring(1, line.Length - 2), out section))
                     {
@@ -53,7 +53,7 @@ namespace osu.Game.Beatmaps.Formats
             }
         }
 
-        protected virtual bool ShouldSkipLine(string line) => string.IsNullOrWhiteSpace(line) || line.StartsWith("//");
+        protected virtual bool ShouldSkipLine(string line) => string.IsNullOrWhiteSpace(line) || line.StartsWith("//", StringComparison.Ordinal);
 
         protected virtual void ParseLine(T output, Section section, string line)
         {

osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs

@@ -60,7 +60,7 @@ namespace osu.Game.Beatmaps.Formats
         private void handleEvents(string line)
         {
             var depth = 0;
-            while (line.StartsWith(" ") || line.StartsWith("_"))
+            while (line.StartsWith(" ", StringComparison.Ordinal) || line.StartsWith("_", StringComparison.Ordinal))
             {
                 ++depth;
                 line = line.Substring(1);
@@ -269,9 +269,9 @@ namespace osu.Game.Beatmaps.Formats
                     return Anchor.BottomCentre;
                 case LegacyOrigins.BottomRight:
                     return Anchor.BottomRight;
+                default:
+                    return Anchor.TopLeft;
             }
-
-            throw new InvalidDataException($@"Unknown origin: {value}");
         }
 
         private void handleVariables(string line)

osu.Game/Database/DatabaseContextFactory.cs

@@ -5,7 +5,6 @@ using System;
 using System.Linq;
 using System.Threading;
 using Microsoft.EntityFrameworkCore.Storage;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Platform;
 
 namespace osu.Game.Database
@@ -118,7 +117,9 @@ namespace osu.Game.Database
 
         private void recycleThreadContexts()
         {
-            threadContexts?.Values.ForEach(c => c.Dispose());
+            // Contexts for other threads are not disposed as they may be in use elsewhere. Instead, fresh contexts are exposed
+            // for other threads to use, and we rely on the finalizer inside OsuDbContext to handle their previous contexts
+            threadContexts?.Value.Dispose();
             threadContexts = new ThreadLocal<OsuDbContext>(CreateContext, true);
         }
 

osu.Game/Database/OsuDbContext.cs

@@ -75,6 +75,13 @@ namespace osu.Game.Database
             }
         }
 
+        ~OsuDbContext()
+        {
+            // DbContext does not contain a finalizer (https://github.com/aspnet/EntityFrameworkCore/issues/8872)
+            // This is used to clean up previous contexts when fresh contexts are exposed via DatabaseContextFactory
+            Dispose();
+        }
+
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
             base.OnConfiguring(optionsBuilder);

osu.Game/Graphics/UserInterface/OsuButton.cs

@@ -1,7 +1,16 @@
 // 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.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Input.EventArgs;
+using osu.Framework.Input.States;
+using osu.Game.Graphics.Sprites;
+using OpenTK.Graphics;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -10,9 +19,73 @@ namespace osu.Game.Graphics.UserInterface
     /// </summary>
     public class OsuButton : Button
     {
+        private Box hover;
+
         public OsuButton()
         {
-            Add(new HoverClickSounds(HoverSampleSet.Loud));
+            Height = 40;
+
+            Content.Masking = true;
+            Content.CornerRadius = 5;
         }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            BackgroundColour = colours.BlueDark;
+
+            AddRange(new Drawable[]
+            {
+                hover = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Blending = BlendingMode.Additive,
+                    Colour = Color4.White.Opacity(0.1f),
+                    Alpha = 0,
+                    Depth = -1
+                },
+                new HoverClickSounds(HoverSampleSet.Loud),
+            });
+
+            Enabled.ValueChanged += enabled_ValueChanged;
+            Enabled.TriggerChange();
+        }
+
+        private void enabled_ValueChanged(bool enabled)
+        {
+            this.FadeColour(enabled ? Color4.White : Color4.Gray, 200, Easing.OutQuint);
+        }
+
+        protected override bool OnHover(InputState state)
+        {
+            hover.FadeIn(200);
+            return base.OnHover(state);
+        }
+
+        protected override void OnHoverLost(InputState state)
+        {
+            hover.FadeOut(200);
+            base.OnHoverLost(state);
+        }
+
+        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        {
+            Content.ScaleTo(0.9f, 4000, Easing.OutQuint);
+            return base.OnMouseDown(state, args);
+        }
+
+        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        {
+            Content.ScaleTo(1, 1000, Easing.OutElastic);
+            return base.OnMouseUp(state, args);
+        }
+
+        protected override SpriteText CreateText() => new OsuSpriteText
+        {
+            Depth = -1,
+            Origin = Anchor.Centre,
+            Anchor = Anchor.Centre,
+            Font = @"Exo2.0-Bold",
+        };
     }
 }

osu.Game/Graphics/UserInterface/TriangleButton.cs

@@ -2,17 +2,10 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
-using OpenTK.Graphics;
 using osu.Framework.Allocation;
-using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.Shapes;
-using osu.Framework.Graphics.Sprites;
-using osu.Framework.Input.EventArgs;
-using osu.Framework.Input.States;
 using osu.Game.Graphics.Backgrounds;
-using osu.Game.Graphics.Sprites;
 
 namespace osu.Game.Graphics.UserInterface
 {
@@ -21,79 +14,17 @@ namespace osu.Game.Graphics.UserInterface
     /// </summary>
     public class TriangleButton : OsuButton, IFilterable
     {
-        private Box hover;
-
-        protected Triangles Triangles;
-
-        public TriangleButton()
-        {
-            Height = 40;
-        }
-
-        protected override SpriteText CreateText() => new OsuSpriteText
-        {
-            Depth = -1,
-            Origin = Anchor.Centre,
-            Anchor = Anchor.Centre,
-            Font = @"Exo2.0-Bold",
-        };
+        protected Triangles Triangles { get; private set; }
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
-            BackgroundColour = colours.BlueDark;
-
-            Content.Masking = true;
-            Content.CornerRadius = 5;
-
-            AddRange(new Drawable[]
+            Add(Triangles = new Triangles
             {
-                Triangles = new Triangles
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    ColourDark = colours.BlueDarker,
-                    ColourLight = colours.Blue,
-                },
-                hover = new Box
-                {
-                    RelativeSizeAxes = Axes.Both,
-                    Blending = BlendingMode.Additive,
-                    Colour = Color4.White.Opacity(0.1f),
-                    Alpha = 0,
-                },
+                RelativeSizeAxes = Axes.Both,
+                ColourDark = colours.BlueDarker,
+                ColourLight = colours.Blue,
             });
-
-            Enabled.ValueChanged += enabled_ValueChanged;
-            Enabled.TriggerChange();
-        }
-
-        private void enabled_ValueChanged(bool enabled)
-        {
-            this.FadeColour(enabled ? Color4.White : Color4.Gray, 200, Easing.OutQuint);
-        }
-
-        protected override bool OnHover(InputState state)
-        {
-            hover.FadeIn(200);
-            return base.OnHover(state);
-        }
-
-        protected override void OnHoverLost(InputState state)
-        {
-            hover.FadeOut(200);
-            base.OnHoverLost(state);
-        }
-
-        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
-        {
-            Content.ScaleTo(0.9f, 4000, Easing.OutQuint);
-            return base.OnMouseDown(state, args);
-        }
-
-        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
-        {
-            Content.ScaleTo(1, 1000, Easing.OutElastic);
-            return base.OnMouseUp(state, args);
         }
 
         public IEnumerable<string> FilterTerms => new[] { Text };

osu.Game/OsuGame.cs

@@ -504,7 +504,25 @@ namespace osu.Game
             // schedule is here to ensure that all component loads are done after LoadComplete is run (and thus all dependencies are cached).
             // with some better organisation of LoadComplete to do construction and dependency caching in one step, followed by calls to loadComponentSingleFile,
             // we could avoid the need for scheduling altogether.
-            Schedule(() => { asyncLoadStream = asyncLoadStream?.ContinueWith(t => LoadComponentAsync(d, add).Wait()) ?? LoadComponentAsync(d, add); });
+            Schedule(() =>
+            {
+                if (asyncLoadStream != null)
+                {
+                    //chain with existing load stream
+                    asyncLoadStream = asyncLoadStream.ContinueWith(async t =>
+                    {
+                        try
+                        {
+                            await LoadComponentAsync(d, add);
+                        }
+                        catch (OperationCanceledException)
+                        {
+                        }
+                    });
+                }
+                else
+                    asyncLoadStream = LoadComponentAsync(d, add);
+            });
         }
 
         public bool OnPressed(GlobalAction action)

osu.Game/Overlays/Settings/Sections/Debug/GCSettings.cs

@@ -13,15 +13,18 @@ namespace osu.Game.Overlays.Settings.Sections.Debug
     {
         protected override string Header => "Garbage Collector";
 
+        private readonly Bindable<LatencyMode> latencyMode = new Bindable<LatencyMode>();
+        private Bindable<GCLatencyMode> configLatencyMode;
+
         [BackgroundDependencyLoader]
         private void load(FrameworkDebugConfigManager config)
         {
             Children = new Drawable[]
             {
-                new SettingsEnumDropdown<GCLatencyMode>
+                new SettingsEnumDropdown<LatencyMode>
                 {
                     LabelText = "Active mode",
-                    Bindable = config.GetBindable<GCLatencyMode>(DebugSetting.ActiveGCMode)
+                    Bindable = latencyMode
                 },
                 new SettingsButton
                 {
@@ -29,6 +32,18 @@ namespace osu.Game.Overlays.Settings.Sections.Debug
                     Action = GC.Collect
                 },
             };
+
+            configLatencyMode = config.GetBindable<GCLatencyMode>(DebugSetting.ActiveGCMode);
+            configLatencyMode.BindValueChanged(v => latencyMode.Value = (LatencyMode)v, true);
+            latencyMode.BindValueChanged(v => configLatencyMode.Value = (GCLatencyMode)v);
+        }
+
+        private enum LatencyMode
+        {
+            Batch = GCLatencyMode.Batch,
+            Interactive = GCLatencyMode.Interactive,
+            LowLatency = GCLatencyMode.LowLatency,
+            SustainedLowLatency = GCLatencyMode.SustainedLowLatency
         }
     }
 }

osu.Game/Overlays/Settings/SidebarButton.cs

@@ -9,6 +9,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.States;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
@@ -16,7 +17,7 @@ using osu.Game.Graphics.UserInterface;
 
 namespace osu.Game.Overlays.Settings
 {
-    public class SidebarButton : OsuButton
+    public class SidebarButton : Button
     {
         private readonly SpriteIcon drawableIcon;
         private readonly SpriteText headerText;
@@ -97,7 +98,8 @@ namespace osu.Game.Overlays.Settings
                     Width = 5,
                     Anchor = Anchor.CentreRight,
                     Origin = Anchor.CentreRight,
-                }
+                },
+                new HoverClickSounds(HoverSampleSet.Loud),
             });
         }
 

osu.Game/Rulesets/Mods/IUpdatableByPlayfield.cs

@@ -0,0 +1,12 @@
+// 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;
+
+namespace osu.Game.Rulesets.Mods
+{
+    public interface IUpdatableByPlayfield : IApplicableMod
+    {
+        void Update(Playfield playfield);
+    }
+}

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

@@ -10,6 +10,8 @@ using System.IO;
 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
@@ -37,6 +39,7 @@ namespace osu.Game.Rulesets.Objects.Legacy
             FormatVersion = formatVersion;
         }
 
+        [CanBeNull]
         public override HitObject Parse(string text)
         {
             try
@@ -191,7 +194,10 @@ namespace osu.Game.Rulesets.Objects.Legacy
                 }
 
                 if (result == null)
-                    throw new InvalidOperationException($@"Unknown hit object type {type}.");
+                {
+                    Logger.Log($"Unknown hit object type: {type}. Skipped.", level: LogLevel.Error);
+                    return null;
+                }
 
                 result.StartTime = Convert.ToDouble(split[2], CultureInfo.InvariantCulture) + Offset;
                 result.Samples = convertSoundType(soundType, bankInfo);

osu.Game/Rulesets/UI/Playfield.cs

@@ -9,6 +9,8 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Configuration;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.UI
 {
@@ -51,9 +53,13 @@ namespace osu.Game.Rulesets.UI
             RelativeSizeAxes = Axes.Both;
         }
 
+        private WorkingBeatmap beatmap;
+
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(IBindableBeatmap beatmap)
         {
+            this.beatmap = beatmap.Value;
+
             HitObjects = CreateHitObjectContainer();
             HitObjects.RelativeSizeAxes = Axes.Both;
 
@@ -92,5 +98,15 @@ namespace osu.Game.Rulesets.UI
         /// Creates the container that will be used to contain the <see cref="DrawableHitObject"/>s.
         /// </summary>
         protected virtual HitObjectContainer CreateHitObjectContainer() => new HitObjectContainer();
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (beatmap != null)
+                foreach (var mod in beatmap.Mods.Value)
+                    if (mod is IUpdatableByPlayfield updatable)
+                        updatable.Update(this);
+        }
     }
 }

osu.Game/Screens/Edit/Components/CircularButton.cs

@@ -0,0 +1,25 @@
+// 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.Graphics.UserInterface;
+using OpenTK;
+
+namespace osu.Game.Screens.Edit.Components
+{
+    public class CircularButton : OsuButton
+    {
+        private const float width = 125;
+        private const float height = 30;
+
+        public CircularButton()
+        {
+            Size = new Vector2(width, height);
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+            Content.CornerRadius = DrawHeight / 2f;
+        }
+    }
+}

osu.Game/Screens/Menu/ButtonSystem.cs

@@ -278,7 +278,7 @@ namespace osu.Game.Screens.Menu
 
             if (logo != null)
             {
-                if (logoTracking && iconFacade.IsLoaded)
+                if (logoTracking && logo.RelativePositionAxes == Axes.None && iconFacade.IsLoaded)
                     logo.Position = logoTrackingPosition;
 
                 iconFacade.Width = logo.SizeForFlow * 0.5f;

osu.Game/Screens/Play/HUD/ModDisplay.cs

@@ -63,6 +63,12 @@ namespace osu.Game.Screens.Play.HUD
             };
         }
 
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            mods.UnbindAll();
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();

osu.Game/Screens/Play/Player.cs

@@ -124,7 +124,7 @@ namespace osu.Game.Screens.Play
 
                 if (!RulesetContainer.Objects.Any())
                 {
-                    Logger.Error(new InvalidOperationException("Beatmap contains no hit objects!"), "Beatmap contains no hit objects!");
+                    Logger.Log("Beatmap contains no hit objects!", level: LogLevel.Error);
                     return;
                 }
             }

osu.Game/osu.Game.csproj

@@ -18,7 +18,7 @@
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.1" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite.Core" Version="2.1.1" />
     <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
-    <PackageReference Include="ppy.osu.Framework" Version="2018.820.1" />
+    <PackageReference Include="ppy.osu.Framework" Version="2018.821.0" />
     <PackageReference Include="SharpCompress" Version="0.22.0" />
     <PackageReference Include="NUnit" Version="3.10.1" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />