Merge branch 'master' into shared-menu-content

osu.Desktop/DiscordRichPresence.cs

@@ -75,7 +75,7 @@ namespace osu.Desktop
             };
 
             client.OnReady += onReady;
-            client.OnError += (_, e) => Logger.Log($"An error occurred with Discord RPC Client: {e.Code} {e.Message}", LoggingTarget.Network, LogLevel.Error);
+            client.OnError += (_, e) => Logger.Log($"An error occurred with Discord RPC Client: {e.Message} ({e.Code})", LoggingTarget.Network, LogLevel.Error);
 
             // A URI scheme is required to support game invitations, as well as informing Discord of the game executable path to support launching the game when a user clicks on join/spectate.
             client.RegisterUriScheme();
@@ -94,10 +94,10 @@ namespace osu.Desktop
                 activity.BindTo(u.NewValue.Activity);
             }, true);
 
-            ruleset.BindValueChanged(_ => updatePresence());
-            status.BindValueChanged(_ => updatePresence());
-            activity.BindValueChanged(_ => updatePresence());
-            privacyMode.BindValueChanged(_ => updatePresence());
+            ruleset.BindValueChanged(_ => schedulePresenceUpdate());
+            status.BindValueChanged(_ => schedulePresenceUpdate());
+            activity.BindValueChanged(_ => schedulePresenceUpdate());
+            privacyMode.BindValueChanged(_ => schedulePresenceUpdate());
             multiplayerClient.RoomUpdated += onRoomUpdated;
 
             client.Initialize();
@@ -111,14 +111,14 @@ namespace osu.Desktop
             if (client.CurrentPresence != null)
                 client.SetPresence(null);
 
-            updatePresence();
+            schedulePresenceUpdate();
         }
 
-        private void onRoomUpdated() => updatePresence();
+        private void onRoomUpdated() => schedulePresenceUpdate();
 
         private ScheduledDelegate? presenceUpdateDelegate;
 
-        private void updatePresence()
+        private void schedulePresenceUpdate()
         {
             presenceUpdateDelegate?.Cancel();
             presenceUpdateDelegate = Scheduler.AddDelayed(() =>
@@ -134,16 +134,14 @@ namespace osu.Desktop
 
                 bool hideIdentifiableInformation = privacyMode.Value == DiscordRichPresenceMode.Limited || status.Value == UserStatus.DoNotDisturb;
 
-                updatePresenceStatus(hideIdentifiableInformation);
-                updatePresenceParty(hideIdentifiableInformation);
-                updatePresenceAssets();
-
+                updatePresence(hideIdentifiableInformation);
                 client.SetPresence(presence);
             }, 200);
         }
 
-        private void updatePresenceStatus(bool hideIdentifiableInformation)
+        private void updatePresence(bool hideIdentifiableInformation)
         {
+            // user activity
             if (activity.Value != null)
             {
                 presence.State = truncate(activity.Value.GetStatus(hideIdentifiableInformation));
@@ -170,10 +168,8 @@ namespace osu.Desktop
                 presence.State = "Idle";
                 presence.Details = string.Empty;
             }
-        }
 
-        private void updatePresenceParty(bool hideIdentifiableInformation)
-        {
+            // user party
             if (!hideIdentifiableInformation && multiplayerClient.Room != null)
             {
                 MultiplayerRoom room = multiplayerClient.Room;
@@ -195,17 +191,18 @@ namespace osu.Desktop
                 };
 
                 presence.Secrets.JoinSecret = JsonConvert.SerializeObject(roomSecret);
+                // discord cannot handle both secrets and buttons at the same time, so we need to choose something.
+                // the multiplayer room seems more important.
+                presence.Buttons = null;
             }
             else
             {
                 presence.Party = null;
                 presence.Secrets.JoinSecret = null;
             }
-        }
 
-        private void updatePresenceAssets()
-        {
-            // update user information
+            // game images:
+            // large image tooltip
             if (privacyMode.Value == DiscordRichPresenceMode.Limited)
                 presence.Assets.LargeImageText = string.Empty;
             else
@@ -216,7 +213,7 @@ namespace osu.Desktop
                     presence.Assets.LargeImageText = $"{user.Value.Username}" + (user.Value.Statistics?.GlobalRank > 0 ? $" (rank #{user.Value.Statistics.GlobalRank:N0})" : string.Empty);
             }
 
-            // update ruleset
+            // small image
             presence.Assets.SmallImageKey = ruleset.Value.IsLegacyRuleset() ? $"mode_{ruleset.Value.OnlineID}" : "mode_custom";
             presence.Assets.SmallImageText = ruleset.Value.Name;
         }

osu.Game.Rulesets.Catch.Tests/Editor/Checks/CheckCatchAbnormalDifficultySettingsTest.cs

@@ -0,0 +1,158 @@
+// 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.Beatmaps;
+using osu.Game.Rulesets.Catch.Edit.Checks;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Rulesets.Catch.Tests.Editor.Checks
+{
+    [TestFixture]
+    public class CheckCatchAbnormalDifficultySettingsTest
+    {
+        private CheckCatchAbnormalDifficultySettings check = null!;
+
+        private readonly IBeatmap beatmap = new Beatmap<HitObject>();
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckCatchAbnormalDifficultySettings();
+
+            beatmap.BeatmapInfo.Ruleset = new CatchRuleset().RulesetInfo;
+            beatmap.Difficulty = new BeatmapDifficulty
+            {
+                ApproachRate = 5,
+                CircleSize = 5,
+                DrainRate = 5,
+            };
+        }
+
+        [Test]
+        public void TestNormalSettings()
+        {
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(0));
+        }
+
+        [Test]
+        public void TestApproachRateTwoDecimals()
+        {
+            beatmap.Difficulty.ApproachRate = 5.55f;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateMoreThanOneDecimal);
+        }
+
+        [Test]
+        public void TestCircleSizeTwoDecimals()
+        {
+            beatmap.Difficulty.CircleSize = 5.55f;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateMoreThanOneDecimal);
+        }
+
+        [Test]
+        public void TestDrainRateTwoDecimals()
+        {
+            beatmap.Difficulty.DrainRate = 5.55f;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateMoreThanOneDecimal);
+        }
+
+        [Test]
+        public void TestApproachRateUnder()
+        {
+            beatmap.Difficulty.ApproachRate = -10;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestCircleSizeUnder()
+        {
+            beatmap.Difficulty.CircleSize = -10;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestDrainRateUnder()
+        {
+            beatmap.Difficulty.DrainRate = -10;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestApproachRateOver()
+        {
+            beatmap.Difficulty.ApproachRate = 20;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestCircleSizeOver()
+        {
+            beatmap.Difficulty.CircleSize = 20;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestDrainRateOver()
+        {
+            beatmap.Difficulty.DrainRate = 20;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        private BeatmapVerifierContext getContext()
+        {
+            return new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+        }
+    }
+}

osu.Game.Rulesets.Catch/Edit/CatchBeatmapVerifier.cs

@@ -13,7 +13,8 @@ namespace osu.Game.Rulesets.Catch.Edit
     {
         private readonly List<ICheck> checks = new List<ICheck>
         {
-            new CheckBananaShowerGap()
+            new CheckBananaShowerGap(),
+            new CheckCatchAbnormalDifficultySettings(),
         };
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)

osu.Game.Rulesets.Catch/Edit/Checks/CheckCatchAbnormalDifficultySettings.cs

@@ -0,0 +1,39 @@
+// 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.Collections.Generic;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Catch.Edit.Checks
+{
+    public class CheckCatchAbnormalDifficultySettings : CheckAbnormalDifficultySettings
+    {
+        public override CheckMetadata Metadata => new CheckMetadata(CheckCategory.Settings, "Checks catch relevant settings");
+
+        public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            var diff = context.Beatmap.Difficulty;
+            Issue? issue;
+
+            if (HasMoreThanOneDecimalPlace("Approach rate", diff.ApproachRate, out issue))
+                yield return issue;
+
+            if (OutOfRange("Approach rate", diff.ApproachRate, out issue))
+                yield return issue;
+
+            if (HasMoreThanOneDecimalPlace("Circle size", diff.CircleSize, out issue))
+                yield return issue;
+
+            if (OutOfRange("Circle size", diff.CircleSize, out issue))
+                yield return issue;
+
+            if (HasMoreThanOneDecimalPlace("Drain rate", diff.DrainRate, out issue))
+                yield return issue;
+
+            if (OutOfRange("Drain rate", diff.DrainRate, out issue))
+                yield return issue;
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckKeyCountTest.cs

@@ -0,0 +1,63 @@
+// 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 NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Rulesets.Mania.Edit.Checks;
+using System.Linq;
+
+namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks
+{
+    [TestFixture]
+    public class CheckKeyCountTest
+    {
+        private CheckKeyCount check = null!;
+
+        private IBeatmap beatmap = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckKeyCount();
+
+            beatmap = new Beatmap<HitObject>
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    Ruleset = new ManiaRuleset().RulesetInfo
+                }
+            };
+        }
+
+        [Test]
+        public void TestKeycountFour()
+        {
+            beatmap.Difficulty.CircleSize = 4;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(0));
+        }
+
+        [Test]
+        public void TestKeycountSmallerThanFour()
+        {
+            beatmap.Difficulty.CircleSize = 1;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckKeyCount.IssueTemplateKeycountTooLow);
+        }
+
+        private BeatmapVerifierContext getContext()
+        {
+            return new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+        }
+    }
+}

osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaAbnormalDifficultySettingsTest.cs

@@ -0,0 +1,121 @@
+// 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.Beatmaps;
+using osu.Game.Rulesets.Mania.Edit.Checks;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Tests.Beatmaps;
+
+namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks
+{
+    [TestFixture]
+    public class CheckManiaAbnormalDifficultySettingsTest
+    {
+        private CheckManiaAbnormalDifficultySettings check = null!;
+
+        private readonly IBeatmap beatmap = new Beatmap<HitObject>();
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckManiaAbnormalDifficultySettings();
+
+            beatmap.BeatmapInfo.Ruleset = new ManiaRuleset().RulesetInfo;
+            beatmap.Difficulty = new BeatmapDifficulty
+            {
+                OverallDifficulty = 5,
+                DrainRate = 5,
+            };
+        }
+
+        [Test]
+        public void TestNormalSettings()
+        {
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(0));
+        }
+
+        [Test]
+        public void TestOverallDifficultyTwoDecimals()
+        {
+            beatmap.Difficulty.OverallDifficulty = 5.55f;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateMoreThanOneDecimal);
+        }
+
+        [Test]
+        public void TestDrainRateTwoDecimals()
+        {
+            beatmap.Difficulty.DrainRate = 5.55f;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateMoreThanOneDecimal);
+        }
+
+        [Test]
+        public void TestOverallDifficultyUnder()
+        {
+            beatmap.Difficulty.OverallDifficulty = -10;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestDrainRateUnder()
+        {
+            beatmap.Difficulty.DrainRate = -10;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestOverallDifficultyOver()
+        {
+            beatmap.Difficulty.OverallDifficulty = 20;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestDrainRateOver()
+        {
+            beatmap.Difficulty.DrainRate = 20;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        private BeatmapVerifierContext getContext()
+        {
+            return new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/Checks/CheckKeyCount.cs

@@ -0,0 +1,39 @@
+// 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.Collections.Generic;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Mania.Edit.Checks
+{
+    public class CheckKeyCount : ICheck
+    {
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Settings, "Check mania keycount.");
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateKeycountTooLow(this),
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            var diff = context.Beatmap.Difficulty;
+
+            if (diff.CircleSize < 4)
+            {
+                yield return new IssueTemplateKeycountTooLow(this).Create(diff.CircleSize);
+            }
+        }
+
+        public class IssueTemplateKeycountTooLow : IssueTemplate
+        {
+            public IssueTemplateKeycountTooLow(ICheck check)
+                : base(check, IssueType.Problem, "Key count is {0} and must be 4 or higher.")
+            {
+            }
+
+            public Issue Create(float current) => new Issue(this, current);
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaAbnormalDifficultySettings.cs

@@ -0,0 +1,33 @@
+// 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.Collections.Generic;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Mania.Edit.Checks
+{
+    public class CheckManiaAbnormalDifficultySettings : CheckAbnormalDifficultySettings
+    {
+        public override CheckMetadata Metadata => new CheckMetadata(CheckCategory.Settings, "Checks mania relevant settings");
+
+        public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            var diff = context.Beatmap.Difficulty;
+            Issue? issue;
+
+            if (HasMoreThanOneDecimalPlace("Overall difficulty", diff.OverallDifficulty, out issue))
+                yield return issue;
+
+            if (OutOfRange("Overall difficulty", diff.OverallDifficulty, out issue))
+                yield return issue;
+
+            if (HasMoreThanOneDecimalPlace("Drain rate", diff.DrainRate, out issue))
+                yield return issue;
+
+            if (OutOfRange("Drain rate", diff.DrainRate, out issue))
+                yield return issue;
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/ManiaBeatmapVerifier.cs

@@ -0,0 +1,26 @@
+// 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.Collections.Generic;
+using System.Linq;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+using osu.Game.Rulesets.Mania.Edit.Checks;
+
+namespace osu.Game.Rulesets.Mania.Edit
+{
+    public class ManiaBeatmapVerifier : IBeatmapVerifier
+    {
+        private readonly List<ICheck> checks = new List<ICheck>
+        {
+            // Settings
+            new CheckKeyCount(),
+            new CheckManiaAbnormalDifficultySettings(),
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            return checks.SelectMany(check => check.Run(context));
+        }
+    }
+}

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -65,6 +65,8 @@ namespace osu.Game.Rulesets.Mania
 
         public override HitObjectComposer CreateHitObjectComposer() => new ManiaHitObjectComposer(this);
 
+        public override IBeatmapVerifier CreateBeatmapVerifier() => new ManiaBeatmapVerifier();
+
         public override ISkin? CreateSkinTransformer(ISkin skin, IBeatmap beatmap)
         {
             switch (skin)

osu.Game.Rulesets.Osu.Tests/Editor/Checks/CheckOsuAbnormalDifficultySettingsTest.cs

@@ -0,0 +1,194 @@
+// 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.Rulesets.Osu.Edit.Checks;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Tests.Beatmaps;
+using System.Linq;
+
+namespace osu.Game.Rulesets.Osu.Tests.Editor.Checks
+{
+    [TestFixture]
+    public class CheckOsuAbnormalDifficultySettingsTest
+    {
+        private CheckOsuAbnormalDifficultySettings check = null!;
+
+        private readonly IBeatmap beatmap = new Beatmap<HitObject>();
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckOsuAbnormalDifficultySettings();
+
+            beatmap.Difficulty = new BeatmapDifficulty
+            {
+                ApproachRate = 5,
+                CircleSize = 5,
+                DrainRate = 5,
+                OverallDifficulty = 5,
+            };
+        }
+
+        [Test]
+        public void TestNormalSettings()
+        {
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(0));
+        }
+
+        [Test]
+        public void TestApproachRateTwoDecimals()
+        {
+            beatmap.Difficulty.ApproachRate = 5.55f;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateMoreThanOneDecimal);
+        }
+
+        [Test]
+        public void TestCircleSizeTwoDecimals()
+        {
+            beatmap.Difficulty.CircleSize = 5.55f;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateMoreThanOneDecimal);
+        }
+
+        [Test]
+        public void TestDrainRateTwoDecimals()
+        {
+            beatmap.Difficulty.DrainRate = 5.55f;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateMoreThanOneDecimal);
+        }
+
+        [Test]
+        public void TestOverallDifficultyTwoDecimals()
+        {
+            beatmap.Difficulty.OverallDifficulty = 5.55f;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateMoreThanOneDecimal);
+        }
+
+        [Test]
+        public void TestApproachRateUnder()
+        {
+            beatmap.Difficulty.ApproachRate = -10;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestCircleSizeUnder()
+        {
+            beatmap.Difficulty.CircleSize = -10;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestDrainRateUnder()
+        {
+            beatmap.Difficulty.DrainRate = -10;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestOverallDifficultyUnder()
+        {
+            beatmap.Difficulty.OverallDifficulty = -10;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestApproachRateOver()
+        {
+            beatmap.Difficulty.ApproachRate = 20;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestCircleSizeOver()
+        {
+            beatmap.Difficulty.CircleSize = 20;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestDrainRateOver()
+        {
+            beatmap.Difficulty.DrainRate = 20;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestOverallDifficultyOver()
+        {
+            beatmap.Difficulty.OverallDifficulty = 20;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        private BeatmapVerifierContext getContext()
+        {
+            return new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Checks/CheckOsuAbnormalDifficultySettings.cs

@@ -0,0 +1,45 @@
+// 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.Collections.Generic;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Osu.Edit.Checks
+{
+    public class CheckOsuAbnormalDifficultySettings : CheckAbnormalDifficultySettings
+    {
+        public override CheckMetadata Metadata => new CheckMetadata(CheckCategory.Settings, "Checks osu relevant settings");
+
+        public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            var diff = context.Beatmap.Difficulty;
+            Issue? issue;
+
+            if (HasMoreThanOneDecimalPlace("Approach rate", diff.ApproachRate, out issue))
+                yield return issue;
+
+            if (OutOfRange("Approach rate", diff.ApproachRate, out issue))
+                yield return issue;
+
+            if (HasMoreThanOneDecimalPlace("Overall difficulty", diff.OverallDifficulty, out issue))
+                yield return issue;
+
+            if (OutOfRange("Overall difficulty", diff.OverallDifficulty, out issue))
+                yield return issue;
+
+            if (HasMoreThanOneDecimalPlace("Circle size", diff.CircleSize, out issue))
+                yield return issue;
+
+            if (OutOfRange("Circle size", diff.CircleSize, out issue))
+                yield return issue;
+
+            if (HasMoreThanOneDecimalPlace("Drain rate", diff.DrainRate, out issue))
+                yield return issue;
+
+            if (OutOfRange("Drain rate", diff.DrainRate, out issue))
+                yield return issue;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/OsuBeatmapVerifier.cs

@@ -21,6 +21,9 @@ namespace osu.Game.Rulesets.Osu.Edit
             new CheckTimeDistanceEquality(),
             new CheckLowDiffOverlaps(),
             new CheckTooShortSliders(),
+
+            // Settings
+            new CheckOsuAbnormalDifficultySettings(),
         };
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)

osu.Game.Rulesets.Taiko.Tests/Editor/Checks/CheckTaikoAbnormalDifficultySettingsTest.cs

@@ -0,0 +1,120 @@
+// 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.Rulesets.Taiko.Edit.Checks;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Tests.Beatmaps;
+using System.Linq;
+
+namespace osu.Game.Rulesets.Taiko.Tests.Editor.Checks
+{
+    [TestFixture]
+    public class CheckTaikoAbnormalDifficultySettingsTest
+    {
+        private CheckTaikoAbnormalDifficultySettings check = null!;
+
+        private readonly IBeatmap beatmap = new Beatmap<HitObject>();
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckTaikoAbnormalDifficultySettings();
+
+            beatmap.BeatmapInfo.Ruleset = new TaikoRuleset().RulesetInfo;
+            beatmap.Difficulty = new BeatmapDifficulty
+            {
+                OverallDifficulty = 5,
+            };
+        }
+
+        [Test]
+        public void TestNormalSettings()
+        {
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(0));
+        }
+
+        [Test]
+        public void TestOverallDifficultyTwoDecimals()
+        {
+            beatmap.Difficulty.OverallDifficulty = 5.55f;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateMoreThanOneDecimal);
+        }
+
+        [Test]
+        public void TestDrainRateTwoDecimals()
+        {
+            beatmap.Difficulty.DrainRate = 5.55f;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateMoreThanOneDecimal);
+        }
+
+        [Test]
+        public void TestOverallDifficultyUnder()
+        {
+            beatmap.Difficulty.OverallDifficulty = -10;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestOverallDifficultyOver()
+        {
+            beatmap.Difficulty.OverallDifficulty = 20;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestDrainRateUnder()
+        {
+            beatmap.Difficulty.DrainRate = -10;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        [Test]
+        public void TestDrainRateOver()
+        {
+            beatmap.Difficulty.DrainRate = 20;
+
+            var context = getContext();
+            var issues = check.Run(context).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(1));
+            Assert.That(issues.Single().Template is CheckAbnormalDifficultySettings.IssueTemplateOutOfRange);
+        }
+
+        private BeatmapVerifierContext getContext()
+        {
+            return new BeatmapVerifierContext(beatmap, new TestWorkingBeatmap(beatmap));
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Difficulty/TaikoLegacyScoreSimulator.cs

@@ -95,6 +95,8 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                 case SwellTick:
                     scoreIncrease = 300;
                     increaseCombo = false;
+                    isBonus = true;
+                    bonusResult = HitResult.IgnoreHit;
                     break;
 
                 case DrumRollTick:

osu.Game.Rulesets.Taiko/Edit/Checks/CheckTaikoAbnormalDifficultySettings.cs

@@ -0,0 +1,33 @@
+// 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.Collections.Generic;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Taiko.Edit.Checks
+{
+    public class CheckTaikoAbnormalDifficultySettings : CheckAbnormalDifficultySettings
+    {
+        public override CheckMetadata Metadata => new CheckMetadata(CheckCategory.Settings, "Checks taiko relevant settings");
+
+        public override IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            var diff = context.Beatmap.Difficulty;
+            Issue? issue;
+
+            if (HasMoreThanOneDecimalPlace("Overall difficulty", diff.OverallDifficulty, out issue))
+                yield return issue;
+
+            if (OutOfRange("Overall difficulty", diff.OverallDifficulty, out issue))
+                yield return issue;
+
+            if (HasMoreThanOneDecimalPlace("Drain rate", diff.DrainRate, out issue))
+                yield return issue;
+
+            if (OutOfRange("Drain rate", diff.DrainRate, out issue))
+                yield return issue;
+        }
+    }
+}

osu.Game.Rulesets.Taiko/Edit/TaikoBeatmapVerifier.cs

@@ -0,0 +1,24 @@
+// 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.Collections.Generic;
+using System.Linq;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks.Components;
+using osu.Game.Rulesets.Taiko.Edit.Checks;
+
+namespace osu.Game.Rulesets.Taiko.Edit
+{
+    public class TaikoBeatmapVerifier : IBeatmapVerifier
+    {
+        private readonly List<ICheck> checks = new List<ICheck>
+        {
+            new CheckTaikoAbnormalDifficultySettings(),
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            return checks.SelectMany(check => check.Run(context));
+        }
+    }
+}

osu.Game.Rulesets.Taiko/TaikoRuleset.cs

@@ -188,6 +188,8 @@ namespace osu.Game.Rulesets.Taiko
 
         public override HitObjectComposer CreateHitObjectComposer() => new TaikoHitObjectComposer(this);
 
+        public override IBeatmapVerifier CreateBeatmapVerifier() => new TaikoBeatmapVerifier();
+
         public override DifficultyCalculator CreateDifficultyCalculator(IWorkingBeatmap beatmap) => new TaikoDifficultyCalculator(RulesetInfo, beatmap);
 
         public override PerformanceCalculator CreatePerformanceCalculator() => new TaikoPerformanceCalculator();

osu.Game.Tests/Editing/Checks/CheckVideoResolutionTest.cs

@@ -0,0 +1,89 @@
+// 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.IO;
+using System.Linq;
+using Moq;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Edit.Checks;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Storyboards;
+using osu.Game.Tests.Beatmaps;
+using osu.Game.Tests.Resources;
+
+namespace osu.Game.Tests.Editing.Checks
+{
+    [TestFixture]
+    public class CheckVideoResolutionTest
+    {
+        private CheckVideoResolution check = null!;
+
+        private IBeatmap beatmap = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            check = new CheckVideoResolution();
+            beatmap = new Beatmap<HitObject>
+            {
+                BeatmapInfo = new BeatmapInfo
+                {
+                    BeatmapSet = new BeatmapSetInfo
+                    {
+                        Files =
+                        {
+                            CheckTestHelpers.CreateMockFile("mp4"),
+                        }
+                    }
+                }
+            };
+        }
+
+        [Test]
+        public void TestNoVideo()
+        {
+            beatmap.BeatmapInfo.BeatmapSet?.Files.Clear();
+
+            var issues = check.Run(getContext(null)).ToList();
+
+            Assert.That(issues, Has.Count.EqualTo(0));
+        }
+
+        [Test]
+        public void TestVideoAcceptableResolution()
+        {
+            using (var resourceStream = TestResources.OpenResource("Videos/test-video.mp4"))
+            {
+                var issues = check.Run(getContext(resourceStream)).ToList();
+                Assert.That(issues, Has.Count.EqualTo(0));
+            }
+        }
+
+        [Test]
+        public void TestVideoHighResolution()
+        {
+            using (var resourceStream = TestResources.OpenResource("Videos/test-video-resolution-high.mp4"))
+            {
+                var issues = check.Run(getContext(resourceStream)).ToList();
+
+                Assert.That(issues, Has.Count.EqualTo(1));
+                Assert.That(issues.Single().Template is CheckVideoResolution.IssueTemplateHighResolution);
+            }
+        }
+
+        private BeatmapVerifierContext getContext(Stream? resourceStream)
+        {
+            var storyboard = new Storyboard();
+            var layer = storyboard.GetLayer("Video");
+            layer.Add(new StoryboardVideo("abc123.mp4", 0));
+
+            var mockWorkingBeatmap = new Mock<TestWorkingBeatmap>(beatmap, null, null);
+            mockWorkingBeatmap.Setup(w => w.GetStream(It.IsAny<string>())).Returns(resourceStream);
+            mockWorkingBeatmap.As<IWorkingBeatmap>().SetupGet(w => w.Storyboard).Returns(storyboard);
+
+            return new BeatmapVerifierContext(beatmap, mockWorkingBeatmap.Object);
+        }
+    }
+}

osu.Game.Tests/NonVisual/Filtering/FilterQueryParserTest.cs

@@ -256,8 +256,8 @@ namespace osu.Game.Tests.NonVisual.Filtering
             const string query = "status=r";
             var filterCriteria = new FilterCriteria();
             FilterQueryParser.ApplyQueries(filterCriteria, query);
-            Assert.AreEqual(BeatmapOnlineStatus.Ranked, filterCriteria.OnlineStatus.Min);
-            Assert.AreEqual(BeatmapOnlineStatus.Ranked, filterCriteria.OnlineStatus.Max);
+            Assert.IsNotEmpty(filterCriteria.OnlineStatus.Values);
+            Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Ranked));
         }
 
         [Test]
@@ -268,10 +268,71 @@ namespace osu.Game.Tests.NonVisual.Filtering
             FilterQueryParser.ApplyQueries(filterCriteria, query);
             Assert.AreEqual("I want the pp", filterCriteria.SearchText.Trim());
             Assert.AreEqual(4, filterCriteria.SearchTerms.Length);
-            Assert.AreEqual(BeatmapOnlineStatus.Ranked, filterCriteria.OnlineStatus.Min);
-            Assert.IsTrue(filterCriteria.OnlineStatus.IsLowerInclusive);
-            Assert.AreEqual(BeatmapOnlineStatus.Ranked, filterCriteria.OnlineStatus.Max);
-            Assert.IsTrue(filterCriteria.OnlineStatus.IsUpperInclusive);
+            Assert.IsNotEmpty(filterCriteria.OnlineStatus.Values);
+            Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Ranked));
+        }
+
+        [Test]
+        public void TestApplyMultipleEqualityStatusQueries()
+        {
+            const string query = "status=ranked status=loved";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.That(filterCriteria.OnlineStatus.Values, Is.Empty);
+        }
+
+        [Test]
+        public void TestApplyEqualStatusQueryWithMultipleValues()
+        {
+            const string query = "status=ranked,loved";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.That(filterCriteria.OnlineStatus.Values, Is.Not.Empty);
+            Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Ranked));
+            Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Loved));
+        }
+
+        [Test]
+        public void TestApplyRangeStatusMatches()
+        {
+            const string query = "status>=r";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.That(filterCriteria.OnlineStatus.Values, Has.Count.EqualTo(4));
+            Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Ranked));
+            Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Approved));
+            Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Qualified));
+            Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Loved));
+        }
+
+        [Test]
+        public void TestApplyRangeStatusWithMultipleMatchesQuery()
+        {
+            const string query = "status>=r,l";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.That(filterCriteria.OnlineStatus.Values, Is.EquivalentTo(Enum.GetValues<BeatmapOnlineStatus>()));
+        }
+
+        [Test]
+        public void TestApplyTwoRangeStatusQuery()
+        {
+            const string query = "status>r status<l";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.That(filterCriteria.OnlineStatus.Values, Has.Count.EqualTo(2));
+            Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Approved));
+            Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Qualified));
+        }
+
+        [Test]
+        public void TestApplyRangeAndEqualStatusQuery()
+        {
+            const string query = "status>r status=loved";
+            var filterCriteria = new FilterCriteria();
+            FilterQueryParser.ApplyQueries(filterCriteria, query);
+            Assert.That(filterCriteria.OnlineStatus.Values, Is.Not.Empty);
+            Assert.That(filterCriteria.OnlineStatus.Values, Contains.Item(BeatmapOnlineStatus.Loved));
         }
 
         [TestCase("creator")]

osu.Game/Rulesets/Edit/BeatmapVerifier.cs

@@ -18,6 +18,7 @@ namespace osu.Game.Rulesets.Edit
             // Resources
             new CheckBackgroundPresence(),
             new CheckBackgroundQuality(),
+            new CheckVideoResolution(),
 
             // Audio
             new CheckAudioPresence(),
@@ -42,7 +43,7 @@ namespace osu.Game.Rulesets.Edit
             new CheckPreviewTime(),
 
             // Events
-            new CheckBreaks()
+            new CheckBreaks(),
         };
 
         public IEnumerable<Issue> Run(BeatmapVerifierContext context)

osu.Game/Rulesets/Edit/Checks/CheckAbnormalDifficultySettings.cs

@@ -0,0 +1,59 @@
+// 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.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using osu.Game.Rulesets.Edit.Checks.Components;
+
+namespace osu.Game.Rulesets.Edit.Checks
+{
+    public abstract class CheckAbnormalDifficultySettings : ICheck
+    {
+        public abstract CheckMetadata Metadata { get; }
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateMoreThanOneDecimal(this),
+            new IssueTemplateOutOfRange(this),
+        };
+
+        public abstract IEnumerable<Issue> Run(BeatmapVerifierContext context);
+
+        /// <summary>
+        /// If the setting is out of the boundaries set by the editor (0 - 10)
+        /// </summary>
+        protected bool OutOfRange(string setting, float value, [NotNullWhen(true)] out Issue? issue)
+        {
+            bool hasIssue = value < 0f || value > 10f;
+            issue = hasIssue ? new IssueTemplateOutOfRange(this).Create(setting, value) : null;
+            return hasIssue;
+        }
+
+        protected bool HasMoreThanOneDecimalPlace(string setting, float value, [NotNullWhen(true)] out Issue? issue)
+        {
+            bool hasIssue = float.Round(value, 1) != value;
+            issue = hasIssue ? new IssueTemplateMoreThanOneDecimal(this).Create(setting, value) : null;
+            return hasIssue;
+        }
+
+        public class IssueTemplateMoreThanOneDecimal : IssueTemplate
+        {
+            public IssueTemplateMoreThanOneDecimal(ICheck check)
+                : base(check, IssueType.Problem, "{0} {1} has more than one decimal place.")
+            {
+            }
+
+            public Issue Create(string settingName, float settingValue) => new Issue(this, settingName, settingValue);
+        }
+
+        public class IssueTemplateOutOfRange : IssueTemplate
+        {
+            public IssueTemplateOutOfRange(ICheck check)
+                : base(check, IssueType.Warning, "{0} is {1} although it is capped between 0 to 10 in-game.")
+            {
+            }
+
+            public Issue Create(string settingName, float settingValue) => new Issue(this, settingName, settingValue);
+        }
+    }
+}

osu.Game/Rulesets/Edit/Checks/CheckVideoResolution.cs

@@ -0,0 +1,116 @@
+// 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.IO;
+using osu.Framework.Logging;
+using osu.Game.Beatmaps;
+using osu.Game.IO.FileAbstraction;
+using osu.Game.Rulesets.Edit.Checks.Components;
+using osu.Game.Storyboards;
+using TagLib;
+using File = TagLib.File;
+
+namespace osu.Game.Rulesets.Edit.Checks
+{
+    public class CheckVideoResolution : ICheck
+    {
+        private const int max_video_width = 1280;
+
+        private const int max_video_height = 720;
+
+        public CheckMetadata Metadata => new CheckMetadata(CheckCategory.Resources, "Too high video resolution.");
+
+        public IEnumerable<IssueTemplate> PossibleTemplates => new IssueTemplate[]
+        {
+            new IssueTemplateHighResolution(this),
+            new IssueTemplateFileError(this),
+        };
+
+        public IEnumerable<Issue> Run(BeatmapVerifierContext context)
+        {
+            var beatmapSet = context.Beatmap.BeatmapInfo.BeatmapSet;
+            var videoPaths = getVideoPaths(context.WorkingBeatmap.Storyboard);
+
+            foreach (string filename in videoPaths)
+            {
+                string? storagePath = beatmapSet?.GetPathForFile(filename);
+
+                // Don't report any issues for missing video here since another check is already doing that (CheckAudioInVideo)
+                if (storagePath == null) continue;
+
+                Issue issue;
+
+                try
+                {
+                    using (Stream data = context.WorkingBeatmap.GetStream(storagePath))
+                    using (File tagFile = File.Create(new StreamFileAbstraction(filename, data)))
+                    {
+                        int height = tagFile.Properties.VideoHeight;
+                        int width = tagFile.Properties.VideoWidth;
+
+                        if (height <= max_video_height || width <= max_video_width)
+                            continue;
+
+                        issue = new IssueTemplateHighResolution(this).Create(filename, width, height);
+                    }
+                }
+                catch (CorruptFileException)
+                {
+                    issue = new IssueTemplateFileError(this).Create(filename, "Corrupt file");
+                }
+                catch (UnsupportedFormatException)
+                {
+                    issue = new IssueTemplateFileError(this).Create(filename, "Unsupported format");
+                }
+                catch (Exception ex)
+                {
+                    issue = new IssueTemplateFileError(this).Create(filename, "Internal failure - see logs for more info");
+                    Logger.Log($"Failed when running {nameof(CheckVideoResolution)}: {ex}");
+                }
+
+                yield return issue;
+            }
+        }
+
+        private List<string> getVideoPaths(Storyboard storyboard)
+        {
+            var videoPaths = new List<string>();
+
+            foreach (var layer in storyboard.Layers)
+            {
+                foreach (var element in layer.Elements)
+                {
+                    if (element is not StoryboardVideo video)
+                        continue;
+
+                    if (!videoPaths.Contains(video.Path))
+                        videoPaths.Add(video.Path);
+                }
+            }
+
+            return videoPaths;
+        }
+
+        public class IssueTemplateHighResolution : IssueTemplate
+        {
+            public IssueTemplateHighResolution(ICheck check)
+                : base(check, IssueType.Problem, "\"{0}\" resolution exceeds 1280x720 ({1}x{2})")
+            {
+            }
+
+            public Issue Create(string filename, int width, int height) => new Issue(this, filename, width, height);
+        }
+
+        public class IssueTemplateFileError : IssueTemplate
+        {
+            public IssueTemplateFileError(ICheck check)
+                : base(check, IssueType.Error, "Could not check resolution for \"{0}\" ({1}).")
+            {
+            }
+
+            public Issue Create(string filename, string errorReason) => new Issue(this, filename, errorReason);
+        }
+    }
+}

osu.Game/Scoring/Legacy/LegacyScoreEncoder.cs

@@ -46,9 +46,10 @@ namespace osu.Game.Scoring.Legacy
         /// <item><description>30000013: All local scores will use lazer definitions of ranks for consistency. Recalculates the rank of all scores.</description></item>
         /// <item><description>30000014: Fix edge cases in conversion for osu! scores on selected beatmaps. Reconvert all scores.</description></item>
         /// <item><description>30000015: Fix osu! standardised score estimation algorithm violating basic invariants. Reconvert all scores.</description></item>
+        /// <item><description>30000016: Fix taiko standardised score estimation algorithm not including swell tick score gain into bonus portion. Reconvert all scores.</description></item>
         /// </list>
         /// </remarks>
-        public const int LATEST_VERSION = 30000015;
+        public const int LATEST_VERSION = 30000016;
 
         /// <summary>
         /// The first stable-compatible YYYYMMDD format version given to lazer usage of replays.

osu.Game/Screens/Select/FilterCriteria.cs

@@ -34,7 +34,7 @@ namespace osu.Game.Screens.Select
         public OptionalRange<double> Length;
         public OptionalRange<double> BPM;
         public OptionalRange<int> BeatDivisor;
-        public OptionalRange<BeatmapOnlineStatus> OnlineStatus;
+        public OptionalSet<BeatmapOnlineStatus> OnlineStatus = new OptionalSet<BeatmapOnlineStatus>();
         public OptionalRange<DateTimeOffset> LastPlayed;
         public OptionalTextFilter Creator;
         public OptionalTextFilter Artist;
@@ -114,6 +114,23 @@ namespace osu.Game.Screens.Select
 
         public IRulesetFilterCriteria? RulesetCriteria { get; set; }
 
+        public readonly struct OptionalSet<T> : IEquatable<OptionalSet<T>>
+            where T : struct, Enum
+        {
+            public bool HasFilter => true;
+
+            public bool IsInRange(T value) => Values.Contains(value);
+
+            public HashSet<T> Values { get; }
+
+            public OptionalSet()
+            {
+                Values = Enum.GetValues<T>().ToHashSet();
+            }
+
+            public bool Equals(OptionalSet<T> other) => Values.SetEquals(other.Values);
+        }
+
         public struct OptionalRange<T> : IEquatable<OptionalRange<T>>
             where T : struct
         {

osu.Game/Screens/Select/FilterQueryParser.cs

@@ -69,7 +69,7 @@ namespace osu.Game.Screens.Select
                     return TryUpdateCriteriaRange(ref criteria.BeatDivisor, op, value, tryParseInt);
 
                 case "status":
-                    return TryUpdateCriteriaRange(ref criteria.OnlineStatus, op, value, tryParseEnum);
+                    return TryUpdateCriteriaSet(ref criteria.OnlineStatus, op, value);
 
                 case "creator":
                 case "author":
@@ -300,6 +300,75 @@ namespace osu.Game.Screens.Select
             where T : struct
             => parseFunction.Invoke(val, out var converted) && tryUpdateCriteriaRange(ref range, op, converted);
 
+        /// <summary>
+        /// Attempts to parse a keyword filter of type <typeparamref name="T"/>,
+        /// from the specified <paramref name="op"/> and <paramref name="filterValue"/>.
+        /// If <paramref name="filterValue"/> can be parsed successfully, the function returns <c>true</c>
+        /// and the resulting range constraint is stored into the <paramref name="range"/>'s expected values.
+        /// </summary>
+        /// <param name="range">The <see cref="FilterCriteria.OptionalSet{T}"/> to store the parsed data into, if successful.</param>
+        /// <param name="op">The operator for the keyword filter.</param>
+        /// <param name="filterValue">The value of the keyword filter.</param>
+        public static bool TryUpdateCriteriaSet<T>(ref FilterCriteria.OptionalSet<T> range, Operator op, string filterValue)
+            where T : struct, Enum
+        {
+            var matchingValues = new HashSet<T>();
+
+            if (op == Operator.Equal && filterValue.Contains(','))
+            {
+                string[] splitValues = filterValue.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+
+                foreach (string splitValue in splitValues)
+                {
+                    if (!tryParseEnum<T>(splitValue, out var parsedValue))
+                        return false;
+
+                    matchingValues.Add(parsedValue);
+                }
+            }
+            else
+            {
+                if (!tryParseEnum<T>(filterValue, out var pivotValue))
+                    return false;
+
+                var allDefinedValues = Enum.GetValues<T>();
+
+                foreach (var val in allDefinedValues)
+                {
+                    int compareResult = Comparer<T>.Default.Compare(val, pivotValue);
+
+                    switch (op)
+                    {
+                        case Operator.Less:
+                            if (compareResult < 0) matchingValues.Add(val);
+                            break;
+
+                        case Operator.LessOrEqual:
+                            if (compareResult <= 0) matchingValues.Add(val);
+                            break;
+
+                        case Operator.Equal:
+                            if (compareResult == 0) matchingValues.Add(val);
+                            break;
+
+                        case Operator.GreaterOrEqual:
+                            if (compareResult >= 0) matchingValues.Add(val);
+                            break;
+
+                        case Operator.Greater:
+                            if (compareResult > 0) matchingValues.Add(val);
+                            break;
+
+                        default:
+                            return false;
+                    }
+                }
+            }
+
+            range.Values.IntersectWith(matchingValues);
+            return true;
+        }
+
         private static bool tryUpdateCriteriaRange<T>(ref FilterCriteria.OptionalRange<T> range, Operator op, T value)
             where T : struct
         {