Merge branch 'master' into taiko-scroller

Directory.Build.props

@@ -16,9 +16,9 @@
     <EmbeddedResource Include="Resources\**\*.*" />
   </ItemGroup>
   <ItemGroup Label="Code Analysis">
-    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="2.9.8" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="3.0.0" PrivateAssets="All" />
     <AdditionalFiles Include="$(MSBuildThisFileDirectory)CodeAnalysis\BannedSymbols.txt" />
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="3.0.0" PrivateAssets="All" />
   </ItemGroup>
   <PropertyGroup Label="Code Analysis">
     <CodeAnalysisRuleSet>$(MSBuildThisFileDirectory)CodeAnalysis\osu.ruleset</CodeAnalysisRuleSet>

osu.Android.props

@@ -52,6 +52,6 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.427.0" />
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.501.0" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2020.508.1" />
   </ItemGroup>
 </Project>

osu.Android/OsuGameAndroid.cs

@@ -18,7 +18,8 @@ namespace osu.Android
 
                 try
                 {
-                    string versionName = packageInfo.VersionCode.ToString();
+                    // todo: needs checking before play store redeploy.
+                    string versionName = packageInfo.VersionName;
                     // undo play store version garbling
                     return new Version(int.Parse(versionName.Substring(0, 4)), int.Parse(versionName.Substring(4, 4)), int.Parse(versionName.Substring(8, 1)));
                 }

osu.Desktop/OsuGameDesktop.cs

@@ -6,15 +6,14 @@ using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
+using Microsoft.Win32;
 using osu.Desktop.Overlays;
 using osu.Framework.Platform;
 using osu.Game;
 using osuTK.Input;
-using Microsoft.Win32;
 using osu.Desktop.Updater;
 using osu.Framework;
 using osu.Framework.Logging;
-using osu.Framework.Platform.Windows;
 using osu.Framework.Screens;
 using osu.Game.Screens.Menu;
 using osu.Game.Updater;
@@ -37,7 +36,11 @@ namespace osu.Desktop
             try
             {
                 if (Host is DesktopGameHost desktopHost)
-                    return new StableStorage(desktopHost);
+                {
+                    string stablePath = getStableInstallPath();
+                    if (!string.IsNullOrEmpty(stablePath))
+                        return new DesktopStorage(stablePath, desktopHost);
+                }
             }
             catch (Exception)
             {
@@ -47,6 +50,35 @@ namespace osu.Desktop
             return null;
         }
 
+        private string getStableInstallPath()
+        {
+            static bool checkExists(string p) => Directory.Exists(Path.Combine(p, "Songs"));
+
+            string stableInstallPath;
+
+            try
+            {
+                using (RegistryKey key = Registry.ClassesRoot.OpenSubKey("osu"))
+                    stableInstallPath = key?.OpenSubKey(@"shell\open\command")?.GetValue(string.Empty).ToString().Split('"')[1].Replace("osu!.exe", "");
+
+                if (checkExists(stableInstallPath))
+                    return stableInstallPath;
+            }
+            catch
+            {
+            }
+
+            stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), @"osu!");
+            if (checkExists(stableInstallPath))
+                return stableInstallPath;
+
+            stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".osu");
+            if (checkExists(stableInstallPath))
+                return stableInstallPath;
+
+            return null;
+        }
+
         protected override UpdateManager CreateUpdateManager()
         {
             switch (RuntimeInfo.OS)
@@ -111,45 +143,5 @@ namespace osu.Desktop
 
             Task.Factory.StartNew(() => Import(filePaths), TaskCreationOptions.LongRunning);
         }
-
-        /// <summary>
-        /// A method of accessing an osu-stable install in a controlled fashion.
-        /// </summary>
-        private class StableStorage : WindowsStorage
-        {
-            protected override string LocateBasePath()
-            {
-                static bool checkExists(string p) => Directory.Exists(Path.Combine(p, "Songs"));
-
-                string stableInstallPath;
-
-                try
-                {
-                    using (RegistryKey key = Registry.ClassesRoot.OpenSubKey("osu"))
-                        stableInstallPath = key?.OpenSubKey(@"shell\open\command")?.GetValue(string.Empty).ToString().Split('"')[1].Replace("osu!.exe", "");
-
-                    if (checkExists(stableInstallPath))
-                        return stableInstallPath;
-                }
-                catch
-                {
-                }
-
-                stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), @"osu!");
-                if (checkExists(stableInstallPath))
-                    return stableInstallPath;
-
-                stableInstallPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".osu");
-                if (checkExists(stableInstallPath))
-                    return stableInstallPath;
-
-                return null;
-            }
-
-            public StableStorage(DesktopGameHost host)
-                : base(string.Empty, host)
-            {
-            }
-        }
     }
 }

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

@@ -13,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Catch";
 
-        [TestCase(4.2058561036909863d, "diffcalc-test")]
+        [TestCase(4.050601681491468d, "diffcalc-test")]
         public void Test(double expected, string name)
             => base.Test(expected, name);
 

osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 {
     public class CatchDifficultyCalculator : DifficultyCalculator
     {
-        private const double star_scaling_factor = 0.145;
+        private const double star_scaling_factor = 0.153;
 
         protected override int SectionLength => 750;
 
@@ -73,6 +73,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty
         {
             halfCatcherWidth = Catcher.CalculateCatchWidth(beatmap.BeatmapInfo.BaseDifficulty) * 0.5f;
 
+            // For circle sizes above 5.5, reduce the catcher width further to simulate imperfect gameplay.
+            halfCatcherWidth *= 1 - (Math.Max(0, beatmap.BeatmapInfo.BaseDifficulty.CircleSize - 5.5f) * 0.0625f);
+
             return new Skill[]
             {
                 new Movement(halfCatcherWidth),

osu.Game.Rulesets.Catch/Difficulty/CatchPerformanceCalculator.cs

@@ -52,8 +52,8 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             // Longer maps are worth more
             double lengthBonus =
-                0.95 + 0.4 * Math.Min(1.0, numTotalHits / 3000.0) +
+                0.95f + 0.3f * Math.Min(1.0f, numTotalHits / 2500.0f) +
-                (numTotalHits > 3000 ? Math.Log10(numTotalHits / 3000.0) * 0.5 : 0.0);
+                (numTotalHits > 2500 ? (float)Math.Log10(numTotalHits / 2500.0f) * 0.475f : 0.0f);
 
             // Longer maps are worth more
             value *= lengthBonus;
@@ -63,19 +63,28 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
             // Combo scaling
             if (Attributes.MaxCombo > 0)
-                value *= Math.Min(Math.Pow(Attributes.MaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
+                value *= Math.Min(Math.Pow(Score.MaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
 
-            double approachRateFactor = 1.0;
+            float approachRate = (float)Attributes.ApproachRate;
-            if (Attributes.ApproachRate > 9.0)
+            float approachRateFactor = 1.0f;
-                approachRateFactor += 0.1 * (Attributes.ApproachRate - 9.0); // 10% for each AR above 9
+            if (approachRate > 9.0f)
-            else if (Attributes.ApproachRate < 8.0)
+                approachRateFactor += 0.1f * (approachRate - 9.0f); // 10% for each AR above 9
-                approachRateFactor += 0.025 * (8.0 - Attributes.ApproachRate); // 2.5% for each AR below 8
+            if (approachRate > 10.0f)
+                approachRateFactor += 0.1f * (approachRate - 10.0f); // Additional 10% at AR 11, 30% total
+            else if (approachRate < 8.0f)
+                approachRateFactor += 0.025f * (8.0f - approachRate); // 2.5% for each AR below 8
 
             value *= approachRateFactor;
 
             if (mods.Any(m => m is ModHidden))
-                // Hiddens gives nothing on max approach rate, and more the lower it is
+            {
                 value *= 1.05 + 0.075 * (10.0 - Math.Min(10.0, Attributes.ApproachRate)); // 7.5% for each AR below 10
+                // Hiddens gives almost nothing on max approach rate, and more the lower it is
+                if (approachRate <= 10.0f)
+                    value *= 1.05f + 0.075f * (10.0f - approachRate); // 7.5% for each AR below 10
+                else if (approachRate > 10.0f)
+                    value *= 1.01f + 0.04f * (11.0f - Math.Min(11.0f, approachRate)); // 5% at AR 10, 1% at AR 11
+            }
 
             if (mods.Any(m => m is ModFlashlight))
                 // Apply length bonus again if flashlight is on simply because it becomes a lot harder on longer maps.

osu.Game.Rulesets.Catch/Difficulty/Preprocessing/CatchDifficultyHitObject.cs

@@ -21,10 +21,12 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
         public readonly float LastNormalizedPosition;
 
         /// <summary>
-        /// Milliseconds elapsed since the start time of the previous <see cref="CatchDifficultyHitObject"/>, with a minimum of 25ms.
+        /// Milliseconds elapsed since the start time of the previous <see cref="CatchDifficultyHitObject"/>, with a minimum of 40ms.
         /// </summary>
         public readonly double StrainTime;
 
+        public readonly double ClockRate;
+
         public CatchDifficultyHitObject(HitObject hitObject, HitObject lastObject, double clockRate, float halfCatcherWidth)
             : base(hitObject, lastObject, clockRate)
         {
@@ -34,8 +36,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Preprocessing
             NormalizedPosition = BaseObject.X * CatchPlayfield.BASE_WIDTH * scalingFactor;
             LastNormalizedPosition = LastObject.X * CatchPlayfield.BASE_WIDTH * scalingFactor;
 
-            // Every strain interval is hard capped at the equivalent of 600 BPM streaming speed as a safety measure
+            // Every strain interval is hard capped at the equivalent of 375 BPM streaming speed as a safety measure
-            StrainTime = Math.Max(25, DeltaTime);
+            StrainTime = Math.Max(40, DeltaTime);
+            ClockRate = clockRate;
         }
     }
 }

osu.Game.Rulesets.Catch/Difficulty/Skills/Movement.cs

@@ -13,9 +13,9 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
     {
         private const float absolute_player_positioning_error = 16f;
         private const float normalized_hitobject_radius = 41.0f;
-        private const double direction_change_bonus = 12.5;
+        private const double direction_change_bonus = 21.0;
 
-        protected override double SkillMultiplier => 850;
+        protected override double SkillMultiplier => 900;
         protected override double StrainDecayBase => 0.2;
 
         protected override double DecayWeight => 0.94;
@@ -24,6 +24,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
         private float? lastPlayerPosition;
         private float lastDistanceMoved;
+        private double lastStrainTime;
 
         public Movement(float halfCatcherWidth)
         {
@@ -45,47 +46,47 @@ namespace osu.Game.Rulesets.Catch.Difficulty.Skills
 
             float distanceMoved = playerPosition - lastPlayerPosition.Value;
 
-            double distanceAddition = Math.Pow(Math.Abs(distanceMoved), 1.3) / 500;
+            double weightedStrainTime = catchCurrent.StrainTime + 13 + (3 / catchCurrent.ClockRate);
-            double sqrtStrain = Math.Sqrt(catchCurrent.StrainTime);
 
-            double bonus = 0;
+            double distanceAddition = (Math.Pow(Math.Abs(distanceMoved), 1.3) / 510);
+            double sqrtStrain = Math.Sqrt(weightedStrainTime);
 
-            // Direction changes give an extra point!
+            double edgeDashBonus = 0;
+
+            // Direction change bonus.
             if (Math.Abs(distanceMoved) > 0.1)
             {
                 if (Math.Abs(lastDistanceMoved) > 0.1 && Math.Sign(distanceMoved) != Math.Sign(lastDistanceMoved))
                 {
-                    double bonusFactor = Math.Min(absolute_player_positioning_error, Math.Abs(distanceMoved)) / absolute_player_positioning_error;
+                    double bonusFactor = Math.Min(50, Math.Abs(distanceMoved)) / 50;
+                    double antiflowFactor = Math.Max(Math.Min(70, Math.Abs(lastDistanceMoved)) / 70, 0.38);
 
-                    distanceAddition += direction_change_bonus / sqrtStrain * bonusFactor;
+                    distanceAddition += direction_change_bonus / Math.Sqrt(lastStrainTime + 16) * bonusFactor * antiflowFactor * Math.Max(1 - Math.Pow(weightedStrainTime / 1000, 3), 0);
-
-                    // Bonus for tougher direction switches and "almost" hyperdashes at this point
-                    if (catchCurrent.LastObject.DistanceToHyperDash <= 10 / CatchPlayfield.BASE_WIDTH)
-                        bonus = 0.3 * bonusFactor;
                 }
 
                 // Base bonus for every movement, giving some weight to streams.
-                distanceAddition += 7.5 * Math.Min(Math.Abs(distanceMoved), normalized_hitobject_radius * 2) / (normalized_hitobject_radius * 6) / sqrtStrain;
+                distanceAddition += 12.5 * Math.Min(Math.Abs(distanceMoved), normalized_hitobject_radius * 2) / (normalized_hitobject_radius * 6) / sqrtStrain;
             }
 
-            // Bonus for "almost" hyperdashes at corner points
+            // Bonus for edge dashes.
-            if (catchCurrent.LastObject.DistanceToHyperDash <= 10.0f / CatchPlayfield.BASE_WIDTH)
+            if (catchCurrent.LastObject.DistanceToHyperDash <= 20.0f / CatchPlayfield.BASE_WIDTH)
             {
                 if (!catchCurrent.LastObject.HyperDash)
-                    bonus += 1.0;
+                    edgeDashBonus += 5.7;
                 else
                 {
                     // After a hyperdash we ARE in the correct position. Always!
                     playerPosition = catchCurrent.NormalizedPosition;
                 }
 
-                distanceAddition *= 1.0 + bonus * ((10 - catchCurrent.LastObject.DistanceToHyperDash * CatchPlayfield.BASE_WIDTH) / 10);
+                distanceAddition *= 1.0 + edgeDashBonus * ((20 - catchCurrent.LastObject.DistanceToHyperDash * CatchPlayfield.BASE_WIDTH) / 20) * Math.Pow((Math.Min(catchCurrent.StrainTime * catchCurrent.ClockRate, 265) / 265), 1.5); // Edge Dashes are easier at lower ms values
             }
 
             lastPlayerPosition = playerPosition;
             lastDistanceMoved = distanceMoved;
+            lastStrainTime = catchCurrent.StrainTime;
 
-            return distanceAddition / catchCurrent.StrainTime;
+            return distanceAddition / weightedStrainTime;
         }
     }
 }

osu.Game.Tests/NonVisual/PeriodTrackerTest.cs

@@ -0,0 +1,85 @@
+// 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.Linq;
+using NUnit.Framework;
+using osu.Framework.Utils;
+using osu.Game.Utils;
+
+namespace osu.Game.Tests.NonVisual
+{
+    [TestFixture]
+    public class PeriodTrackerTest
+    {
+        private static readonly Period[] single_period = { new Period(1.0, 2.0) };
+
+        private static readonly Period[] unordered_periods =
+        {
+            new Period(-9.1, -8.3),
+            new Period(-3.4, 2.1),
+            new Period(9.0, 50.0),
+            new Period(5.25, 10.50)
+        };
+
+        [Test]
+        public void TestCheckValueInsideSinglePeriod()
+        {
+            var tracker = new PeriodTracker(single_period);
+
+            var period = single_period.Single();
+            Assert.IsTrue(tracker.IsInAny(period.Start));
+            Assert.IsTrue(tracker.IsInAny(getMidpoint(period)));
+            Assert.IsTrue(tracker.IsInAny(period.End));
+        }
+
+        [Test]
+        public void TestCheckValuesInsidePeriods()
+        {
+            var tracker = new PeriodTracker(unordered_periods);
+
+            foreach (var period in unordered_periods)
+                Assert.IsTrue(tracker.IsInAny(getMidpoint(period)));
+        }
+
+        [Test]
+        public void TestCheckValuesInRandomOrder()
+        {
+            var tracker = new PeriodTracker(unordered_periods);
+
+            foreach (var period in unordered_periods.OrderBy(_ => RNG.Next()))
+                Assert.IsTrue(tracker.IsInAny(getMidpoint(period)));
+        }
+
+        [Test]
+        public void TestCheckValuesOutOfPeriods()
+        {
+            var tracker = new PeriodTracker(new[]
+            {
+                new Period(1.0, 2.0),
+                new Period(3.0, 4.0)
+            });
+
+            Assert.IsFalse(tracker.IsInAny(0.9), "Time before first period is being considered inside");
+
+            Assert.IsFalse(tracker.IsInAny(2.1), "Time right after first period is being considered inside");
+            Assert.IsFalse(tracker.IsInAny(2.9), "Time right before second period is being considered inside");
+
+            Assert.IsFalse(tracker.IsInAny(4.1), "Time after last period is being considered inside");
+        }
+
+        [Test]
+        public void TestReversedPeriodHandling()
+        {
+            Assert.Throws<ArgumentException>(() =>
+            {
+                _ = new PeriodTracker(new[]
+                {
+                    new Period(2.0, 1.0)
+                });
+            });
+        }
+
+        private double getMidpoint(Period period) => period.Start + (period.End - period.Start) / 2;
+    }
+}

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

@@ -52,7 +52,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep($"seek to break {breakIndex}", () => Player.GameplayClockContainer.Seek(destBreak().StartTime));
             AddUntilStep("wait for seek to complete", () => Player.HUDOverlay.Progress.ReferenceClock.CurrentTime >= destBreak().StartTime);
 
-            BreakPeriod destBreak() => Player.ChildrenOfType<BreakTracker>().First().Breaks.ElementAt(breakIndex);
+            BreakPeriod destBreak() => Beatmap.Value.Beatmap.Breaks.ElementAt(breakIndex);
         }
     }
 }

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

@@ -97,8 +97,6 @@ namespace osu.Game.Tests.Visual.Gameplay
             loadBreaksStep("multiple breaks", testBreaks);
 
             seekAndAssertBreak("seek to break start", testBreaks[1].StartTime, true);
-            AddAssert("is skipped to break #2", () => breakTracker.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);
@@ -174,8 +172,6 @@ namespace osu.Game.Tests.Visual.Gameplay
             private readonly ManualClock manualClock;
             private IFrameBasedClock originalClock;
 
-            public new int CurrentBreakIndex => base.CurrentBreakIndex;
-
             public double ManualClockTime
             {
                 get => manualClock.CurrentTime;

osu.Game.Tests/Visual/SongSelect/TestScenePlaySongSelect.cs

@@ -24,10 +24,12 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
 using osu.Game.Rulesets.Taiko;
+using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Select;
 using osu.Game.Screens.Select.Carousel;
 using osu.Game.Screens.Select.Filter;
+using osu.Game.Users;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.SongSelect
@@ -110,7 +112,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             createSongSelect();
 
-            AddUntilStep("wait for initial selection", () => !Beatmap.IsDefault);
+            waitForInitialSelection();
 
             WorkingBeatmap selected = null;
 
@@ -135,7 +137,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             createSongSelect();
 
-            AddUntilStep("wait for initial selection", () => !Beatmap.IsDefault);
+            waitForInitialSelection();
 
             WorkingBeatmap selected = null;
 
@@ -189,7 +191,7 @@ namespace osu.Game.Tests.Visual.SongSelect
 
             createSongSelect();
 
-            AddUntilStep("wait for initial selection", () => !Beatmap.IsDefault);
+            waitForInitialSelection();
 
             WorkingBeatmap selected = null;
 
@@ -769,6 +771,76 @@ namespace osu.Game.Tests.Visual.SongSelect
             AddAssert("Check first item in group selected", () => Beatmap.Value.BeatmapInfo == groupIcon.Items.First().Beatmap);
         }
 
+        [Test]
+        public void TestChangeRulesetWhilePresentingScore()
+        {
+            BeatmapInfo getPresentBeatmap() => manager.QueryBeatmap(b => !b.BeatmapSet.DeletePending && b.RulesetID == 0);
+            BeatmapInfo getSwitchBeatmap() => manager.QueryBeatmap(b => !b.BeatmapSet.DeletePending && b.RulesetID == 1);
+
+            changeRuleset(0);
+
+            createSongSelect();
+
+            addRulesetImportStep(0);
+            addRulesetImportStep(1);
+
+            AddStep("present score", () =>
+            {
+                // this ruleset change should be overridden by the present.
+                Ruleset.Value = getSwitchBeatmap().Ruleset;
+
+                songSelect.PresentScore(new ScoreInfo
+                {
+                    User = new User { Username = "woo" },
+                    Beatmap = getPresentBeatmap(),
+                    Ruleset = getPresentBeatmap().Ruleset
+                });
+            });
+
+            AddUntilStep("wait for results screen presented", () => !songSelect.IsCurrentScreen());
+
+            AddAssert("check beatmap is correct for score", () => Beatmap.Value.BeatmapInfo.Equals(getPresentBeatmap()));
+            AddAssert("check ruleset is correct for score", () => Ruleset.Value.ID == 0);
+        }
+
+        [Test]
+        public void TestChangeBeatmapWhilePresentingScore()
+        {
+            BeatmapInfo getPresentBeatmap() => manager.QueryBeatmap(b => !b.BeatmapSet.DeletePending && b.RulesetID == 0);
+            BeatmapInfo getSwitchBeatmap() => manager.QueryBeatmap(b => !b.BeatmapSet.DeletePending && b.RulesetID == 1);
+
+            changeRuleset(0);
+
+            addRulesetImportStep(0);
+            addRulesetImportStep(1);
+
+            createSongSelect();
+
+            AddStep("present score", () =>
+            {
+                // this beatmap change should be overridden by the present.
+                Beatmap.Value = manager.GetWorkingBeatmap(getSwitchBeatmap());
+
+                songSelect.PresentScore(new ScoreInfo
+                {
+                    User = new User { Username = "woo" },
+                    Beatmap = getPresentBeatmap(),
+                    Ruleset = getPresentBeatmap().Ruleset
+                });
+            });
+
+            AddUntilStep("wait for results screen presented", () => !songSelect.IsCurrentScreen());
+
+            AddAssert("check beatmap is correct for score", () => Beatmap.Value.BeatmapInfo.Equals(getPresentBeatmap()));
+            AddAssert("check ruleset is correct for score", () => Ruleset.Value.ID == 0);
+        }
+
+        private void waitForInitialSelection()
+        {
+            AddUntilStep("wait for initial selection", () => !Beatmap.IsDefault);
+            AddUntilStep("wait for difficulty panels visible", () => songSelect.Carousel.ChildrenOfType<DrawableCarouselBeatmap>().Any());
+        }
+
         private int getBeatmapIndex(BeatmapSetInfo set, BeatmapInfo info) => set.Beatmaps.FindIndex(b => b == info);
 
         private int getCurrentBeatmapIndex() => getBeatmapIndex(songSelect.Carousel.SelectedBeatmapSet, songSelect.Carousel.SelectedBeatmap);
@@ -876,6 +948,8 @@ namespace osu.Game.Tests.Visual.SongSelect
             public WorkingBeatmap CurrentBeatmapDetailsBeatmap => BeatmapDetails.Beatmap;
             public new BeatmapCarousel Carousel => base.Carousel;
 
+            public new void PresentScore(ScoreInfo score) => base.PresentScore(score);
+
             protected override bool OnStart()
             {
                 StartRequested?.Invoke();

osu.Game.Tournament/IPC/FileBasedIPC.cs

@@ -8,7 +8,6 @@ using Microsoft.Win32;
 using osu.Framework.Allocation;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
-using osu.Framework.Platform.Windows;
 using osu.Framework.Threading;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.Legacy;
@@ -52,7 +51,12 @@ namespace osu.Game.Tournament.IPC
 
             try
             {
-                Storage = new StableStorage(host as DesktopGameHost);
+                var path = findStablePath();
+
+                if (string.IsNullOrEmpty(path))
+                    return null;
+
+                Storage = new DesktopStorage(path, host as DesktopGameHost);
 
                 const string file_ipc_filename = "ipc.txt";
                 const string file_ipc_state_filename = "ipc-state.txt";
@@ -145,17 +149,9 @@ namespace osu.Game.Tournament.IPC
             return Storage;
         }
 
-        /// <summary>
+        private string findStablePath()
-        /// A method of accessing an osu-stable install in a controlled fashion.
-        /// </summary>
-        private class StableStorage : WindowsStorage
         {
-            protected override string LocateBasePath()
+            static bool checkExists(string p) => File.Exists(Path.Combine(p, "ipc.txt"));
-            {
-                static bool checkExists(string p)
-                {
-                    return File.Exists(Path.Combine(p, "ipc.txt"));
-                }
 
             string stableInstallPath = string.Empty;
 
@@ -199,11 +195,5 @@ namespace osu.Game.Tournament.IPC
                 Logger.Log($"Stable path for tourney usage: {stableInstallPath}");
             }
         }
-
-            public StableStorage(DesktopGameHost host)
-                : base(string.Empty, host)
-            {
-            }
-        }
     }
 }

osu.Game.Tournament/Models/LadderInfo.cs

@@ -32,5 +32,11 @@ namespace osu.Game.Tournament.Models
             MinValue = 640,
             MaxValue = 1366,
         };
+
+        public Bindable<int> PlayersPerTeam = new BindableInt(4)
+        {
+            MinValue = 3,
+            MaxValue = 4,
+        };
     }
 }

osu.Game.Tournament/Screens/Gameplay/GameplayScreen.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Tournament.Screens.Gameplay
         [Resolved]
         private TournamentMatchChatDisplay chat { get; set; }
 
-        private Box chroma;
+        private Drawable chroma;
 
         [BackgroundDependencyLoader]
         private void load(LadderInfo ladder, MatchIPCInfo ipc, Storage storage)
@@ -61,16 +61,30 @@ namespace osu.Game.Tournament.Screens.Gameplay
                     Y = 110,
                     Anchor = Anchor.TopCentre,
                     Origin = Anchor.TopCentre,
-                    Children = new Drawable[]
+                    Children = new[]
                     {
-                        chroma = new Box
+                        chroma = new Container
                         {
-                            // chroma key area for stable gameplay
-                            Name = "chroma",
                             Anchor = Anchor.TopCentre,
                             Origin = Anchor.TopCentre,
                             Height = 512,
-                            Colour = new Color4(0, 255, 0, 255),
+                            Children = new Drawable[]
+                            {
+                                new ChromaArea
+                                {
+                                    Name = "Left chroma",
+                                    RelativeSizeAxes = Axes.Both,
+                                    Width = 0.5f,
+                                },
+                                new ChromaArea
+                                {
+                                    Name = "Right chroma",
+                                    RelativeSizeAxes = Axes.Both,
+                                    Anchor = Anchor.TopRight,
+                                    Origin = Anchor.TopRight,
+                                    Width = 0.5f,
+                                }
+                            }
                         },
                     }
                 },
@@ -98,9 +112,15 @@ namespace osu.Game.Tournament.Screens.Gameplay
                         },
                         new SettingsSlider<int>
                         {
-                            LabelText = "Chroma Width",
+                            LabelText = "Chroma width",
                             Bindable = LadderInfo.ChromaKeyWidth,
                             KeyboardStep = 1,
+                        },
+                        new SettingsSlider<int>
+                        {
+                            LabelText = "Players per team",
+                            Bindable = LadderInfo.PlayersPerTeam,
+                            KeyboardStep = 1,
                         }
                     }
                 }
@@ -201,5 +221,54 @@ namespace osu.Game.Tournament.Screens.Gameplay
                 lastState = state.NewValue;
             }
         }
+
+        private class ChromaArea : CompositeDrawable
+        {
+            [Resolved]
+            private LadderInfo ladder { get; set; }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                // chroma key area for stable gameplay
+                Colour = new Color4(0, 255, 0, 255);
+
+                ladder.PlayersPerTeam.BindValueChanged(performLayout, true);
+            }
+
+            private void performLayout(ValueChangedEvent<int> playerCount)
+            {
+                switch (playerCount.NewValue)
+                {
+                    case 3:
+                        InternalChildren = new Drawable[]
+                        {
+                            new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Width = 0.5f,
+                                Height = 0.5f,
+                                Anchor = Anchor.TopCentre,
+                                Origin = Anchor.TopCentre,
+                            },
+                            new Box
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Anchor = Anchor.BottomLeft,
+                                Origin = Anchor.BottomLeft,
+                                Height = 0.5f,
+                            },
+                        };
+                        break;
+
+                    default:
+                        InternalChild = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                        };
+                        break;
+                }
+            }
+        }
     }
 }

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -149,6 +149,11 @@ namespace osu.Game.Beatmaps
             }
         }
 
+        public string[] SearchableTerms => new[]
+        {
+            Version
+        }.Concat(Metadata?.SearchableTerms ?? Enumerable.Empty<string>()).Where(s => !string.IsNullOrEmpty(s)).ToArray();
+
         public override string ToString()
         {
             string version = string.IsNullOrEmpty(Version) ? string.Empty : $"[{Version}]";

osu.Game/Beatmaps/BeatmapManager.cs

@@ -17,7 +17,6 @@ using osu.Framework.Graphics.Textures;
 using osu.Framework.Lists;
 using osu.Framework.Logging;
 using osu.Framework.Platform;
-using osu.Framework.Threading;
 using osu.Game.Beatmaps.Formats;
 using osu.Game.Database;
 using osu.Game.IO;
@@ -61,7 +60,7 @@ namespace osu.Game.Beatmaps
         private readonly BeatmapStore beatmaps;
         private readonly AudioManager audioManager;
         private readonly GameHost host;
-        private readonly BeatmapUpdateQueue updateQueue;
+        private readonly BeatmapOnlineLookupQueue onlineLookupQueue;
         private readonly Storage exportStorage;
 
         public BeatmapManager(Storage storage, IDatabaseContextFactory contextFactory, RulesetStore rulesets, IAPIProvider api, AudioManager audioManager, GameHost host = null,
@@ -78,7 +77,7 @@ namespace osu.Game.Beatmaps
             beatmaps.BeatmapHidden += b => BeatmapHidden?.Invoke(b);
             beatmaps.BeatmapRestored += b => BeatmapRestored?.Invoke(b);
 
-            updateQueue = new BeatmapUpdateQueue(api);
+            onlineLookupQueue = new BeatmapOnlineLookupQueue(api, storage);
             exportStorage = storage.GetStorageForDirectory("exports");
         }
 
@@ -105,7 +104,7 @@ namespace osu.Game.Beatmaps
 
             bool hadOnlineBeatmapIDs = beatmapSet.Beatmaps.Any(b => b.OnlineBeatmapID > 0);
 
-            await updateQueue.UpdateAsync(beatmapSet, cancellationToken);
+            await onlineLookupQueue.UpdateAsync(beatmapSet, cancellationToken);
 
             // ensure at least one beatmap was able to retrieve or keep an online ID, else drop the set ID.
             if (hadOnlineBeatmapIDs && !beatmapSet.Beatmaps.Any(b => b.OnlineBeatmapID > 0))
@@ -141,7 +140,7 @@ namespace osu.Game.Beatmaps
         {
             var beatmapIds = beatmapSet.Beatmaps.Where(b => b.OnlineBeatmapID.HasValue).Select(b => b.OnlineBeatmapID).ToList();
 
-            LogForModel(beatmapSet, "Validating online IDs...");
+            LogForModel(beatmapSet, $"Validating online IDs for {beatmapSet.Beatmaps.Count} beatmaps...");
 
             // ensure all IDs are unique
             if (beatmapIds.GroupBy(b => b).Any(g => g.Count() > 1))
@@ -446,71 +445,6 @@ namespace osu.Game.Beatmaps
             protected override Texture GetBackground() => null;
             protected override Track GetTrack() => null;
         }
-
-        private class BeatmapUpdateQueue
-        {
-            private readonly IAPIProvider api;
-
-            private const int update_queue_request_concurrency = 4;
-
-            private readonly ThreadedTaskScheduler updateScheduler = new ThreadedTaskScheduler(update_queue_request_concurrency, nameof(BeatmapUpdateQueue));
-
-            public BeatmapUpdateQueue(IAPIProvider api)
-            {
-                this.api = api;
-            }
-
-            public Task UpdateAsync(BeatmapSetInfo beatmapSet, CancellationToken cancellationToken)
-            {
-                if (api?.State != APIState.Online)
-                    return Task.CompletedTask;
-
-                LogForModel(beatmapSet, "Performing online lookups...");
-                return Task.WhenAll(beatmapSet.Beatmaps.Select(b => UpdateAsync(beatmapSet, b, cancellationToken)).ToArray());
-            }
-
-            // todo: expose this when we need to do individual difficulty lookups.
-            protected Task UpdateAsync(BeatmapSetInfo beatmapSet, BeatmapInfo beatmap, CancellationToken cancellationToken)
-                => Task.Factory.StartNew(() => update(beatmapSet, beatmap), cancellationToken, TaskCreationOptions.HideScheduler, updateScheduler);
-
-            private void update(BeatmapSetInfo set, BeatmapInfo beatmap)
-            {
-                if (api?.State != APIState.Online)
-                    return;
-
-                var req = new GetBeatmapRequest(beatmap);
-
-                req.Failure += fail;
-
-                try
-                {
-                    // intentionally blocking to limit web request concurrency
-                    api.Perform(req);
-
-                    var res = req.Result;
-
-                    if (res != null)
-                    {
-                        beatmap.Status = res.Status;
-                        beatmap.BeatmapSet.Status = res.BeatmapSet.Status;
-                        beatmap.BeatmapSet.OnlineBeatmapSetID = res.OnlineBeatmapSetID;
-                        beatmap.OnlineBeatmapID = res.OnlineBeatmapID;
-
-                        LogForModel(set, $"Online retrieval mapped {beatmap} to {res.OnlineBeatmapSetID} / {res.OnlineBeatmapID}.");
-                    }
-                }
-                catch (Exception e)
-                {
-                    fail(e);
-                }
-
-                void fail(Exception e)
-                {
-                    beatmap.OnlineBeatmapID = null;
-                    LogForModel(set, $"Online retrieval failed for {beatmap} ({e.Message})");
-                }
-            }
-        }
     }
 
     /// <summary>

osu.Game/Beatmaps/BeatmapManager_BeatmapOnlineLookupQueue.cs

@@ -0,0 +1,195 @@
+// 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.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Dapper;
+using Microsoft.Data.Sqlite;
+using osu.Framework.Development;
+using osu.Framework.IO.Network;
+using osu.Framework.Logging;
+using osu.Framework.Platform;
+using osu.Framework.Threading;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using SharpCompress.Compressors;
+using SharpCompress.Compressors.BZip2;
+
+namespace osu.Game.Beatmaps
+{
+    public partial class BeatmapManager
+    {
+        private class BeatmapOnlineLookupQueue
+        {
+            private readonly IAPIProvider api;
+            private readonly Storage storage;
+
+            private const int update_queue_request_concurrency = 4;
+
+            private readonly ThreadedTaskScheduler updateScheduler = new ThreadedTaskScheduler(update_queue_request_concurrency, nameof(BeatmapOnlineLookupQueue));
+
+            private FileWebRequest cacheDownloadRequest;
+
+            private const string cache_database_name = "online.db";
+
+            public BeatmapOnlineLookupQueue(IAPIProvider api, Storage storage)
+            {
+                this.api = api;
+                this.storage = storage;
+
+                // avoid downloading / using cache for unit tests.
+                if (!DebugUtils.IsNUnitRunning && !storage.Exists(cache_database_name))
+                    prepareLocalCache();
+            }
+
+            public Task UpdateAsync(BeatmapSetInfo beatmapSet, CancellationToken cancellationToken)
+            {
+                if (api?.State != APIState.Online)
+                    return Task.CompletedTask;
+
+                LogForModel(beatmapSet, "Performing online lookups...");
+                return Task.WhenAll(beatmapSet.Beatmaps.Select(b => UpdateAsync(beatmapSet, b, cancellationToken)).ToArray());
+            }
+
+            // todo: expose this when we need to do individual difficulty lookups.
+            protected Task UpdateAsync(BeatmapSetInfo beatmapSet, BeatmapInfo beatmap, CancellationToken cancellationToken)
+                => Task.Factory.StartNew(() => lookup(beatmapSet, beatmap), cancellationToken, TaskCreationOptions.HideScheduler, updateScheduler);
+
+            private void lookup(BeatmapSetInfo set, BeatmapInfo beatmap)
+            {
+                if (checkLocalCache(set, beatmap))
+                    return;
+
+                if (api?.State != APIState.Online)
+                    return;
+
+                var req = new GetBeatmapRequest(beatmap);
+
+                req.Failure += fail;
+
+                try
+                {
+                    // intentionally blocking to limit web request concurrency
+                    api.Perform(req);
+
+                    var res = req.Result;
+
+                    if (res != null)
+                    {
+                        beatmap.Status = res.Status;
+                        beatmap.BeatmapSet.Status = res.BeatmapSet.Status;
+                        beatmap.BeatmapSet.OnlineBeatmapSetID = res.OnlineBeatmapSetID;
+                        beatmap.OnlineBeatmapID = res.OnlineBeatmapID;
+
+                        LogForModel(set, $"Online retrieval mapped {beatmap} to {res.OnlineBeatmapSetID} / {res.OnlineBeatmapID}.");
+                    }
+                }
+                catch (Exception e)
+                {
+                    fail(e);
+                }
+
+                void fail(Exception e)
+                {
+                    beatmap.OnlineBeatmapID = null;
+                    LogForModel(set, $"Online retrieval failed for {beatmap} ({e.Message})");
+                }
+            }
+
+            private void prepareLocalCache()
+            {
+                string cacheFilePath = storage.GetFullPath(cache_database_name);
+                string compressedCacheFilePath = $"{cacheFilePath}.bz2";
+
+                cacheDownloadRequest = new FileWebRequest(compressedCacheFilePath, $"https://assets.ppy.sh/client-resources/{cache_database_name}.bz2");
+
+                cacheDownloadRequest.Failed += ex =>
+                {
+                    File.Delete(compressedCacheFilePath);
+                    File.Delete(cacheFilePath);
+
+                    Logger.Log($"{nameof(BeatmapOnlineLookupQueue)}'s online cache download failed: {ex}", LoggingTarget.Database);
+                };
+
+                cacheDownloadRequest.Finished += () =>
+                {
+                    try
+                    {
+                        using (var stream = File.OpenRead(cacheDownloadRequest.Filename))
+                        using (var outStream = File.OpenWrite(cacheFilePath))
+                        using (var bz2 = new BZip2Stream(stream, CompressionMode.Decompress, false))
+                            bz2.CopyTo(outStream);
+
+                        // set to null on completion to allow lookups to begin using the new source
+                        cacheDownloadRequest = null;
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.Log($"{nameof(BeatmapOnlineLookupQueue)}'s online cache extraction failed: {ex}", LoggingTarget.Database);
+                        File.Delete(cacheFilePath);
+                    }
+                    finally
+                    {
+                        File.Delete(compressedCacheFilePath);
+                    }
+                };
+
+                cacheDownloadRequest.PerformAsync();
+            }
+
+            private bool checkLocalCache(BeatmapSetInfo set, BeatmapInfo beatmap)
+            {
+                // download is in progress (or was, and failed).
+                if (cacheDownloadRequest != null)
+                    return false;
+
+                // database is unavailable.
+                if (!storage.Exists(cache_database_name))
+                    return false;
+
+                try
+                {
+                    using (var db = new SqliteConnection(storage.GetDatabaseConnectionString("online")))
+                    {
+                        var found = db.QuerySingleOrDefault<CachedOnlineBeatmapLookup>(
+                            "SELECT * FROM osu_beatmaps WHERE checksum = @MD5Hash OR beatmap_id = @OnlineBeatmapID OR filename = @Path", beatmap);
+
+                        if (found != null)
+                        {
+                            var status = (BeatmapSetOnlineStatus)found.approved;
+
+                            beatmap.Status = status;
+                            beatmap.BeatmapSet.Status = status;
+                            beatmap.BeatmapSet.OnlineBeatmapSetID = found.beatmapset_id;
+                            beatmap.OnlineBeatmapID = found.beatmap_id;
+
+                            LogForModel(set, $"Cached local retrieval for {beatmap}.");
+                            return true;
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    LogForModel(set, $"Cached local retrieval for {beatmap} failed with {ex}.");
+                }
+
+                return false;
+            }
+
+            [Serializable]
+            [SuppressMessage("ReSharper", "InconsistentNaming")]
+            private class CachedOnlineBeatmapLookup
+            {
+                public int approved { get; set; }
+
+                public int? beatmapset_id { get; set; }
+
+                public int? beatmap_id { get; set; }
+            }
+        }
+    }
+}

osu.Game/Database/ArchiveModelManager.cs

@@ -245,7 +245,7 @@ namespace osu.Game.Database
         /// </summary>
         protected abstract string[] HashableFileTypes { get; }
 
-        protected static void LogForModel(TModel model, string message, Exception e = null)
+        internal static void LogForModel(TModel model, string message, Exception e = null)
         {
             string prefix = $"[{(model?.Hash ?? "?????").Substring(0, 5)}]";
 

osu.Game/Graphics/DrawableDate.cs

@@ -139,7 +139,7 @@ namespace osu.Game.Graphics
                     return false;
 
                 dateText.Text = $"{date:d MMMM yyyy} ";
-                timeText.Text = $"{date:hh:mm:ss \"UTC\"z}";
+                timeText.Text = $"{date:HH:mm:ss \"UTC\"z}";
                 return true;
             }
 

osu.Game/Online/Chat/Channel.cs

@@ -61,7 +61,7 @@ namespace osu.Game.Online.Chat
         /// </summary>
         public event Action<Message> MessageRemoved;
 
-        public bool ReadOnly => false; //todo not yet used.
+        public bool ReadOnly => false; // todo: not yet used.
 
         public override string ToString() => Name;
 

osu.Game/Overlays/SearchableList/DisplayStyleControl.cs

@@ -91,6 +91,8 @@ namespace osu.Game.Overlays.SearchableList
 
             protected override void Dispose(bool isDisposing)
             {
+                base.Dispose(isDisposing);
+
                 bindable.ValueChanged -= Bindable_ValueChanged;
             }
         }

osu.Game/Rulesets/Scoring/HitResult.cs

@@ -43,5 +43,25 @@ namespace osu.Game.Rulesets.Scoring
         /// </summary>
         [Description(@"Perfect")]
         Perfect,
+
+        /// <summary>
+        /// Indicates small tick miss.
+        /// </summary>
+        SmallTickMiss,
+
+        /// <summary>
+        /// Indicates a small tick hit.
+        /// </summary>
+        SmallTickHit,
+
+        /// <summary>
+        /// Indicates a large tick miss.
+        /// </summary>
+        LargeTickMiss,
+
+        /// <summary>
+        /// Indicates a large tick hit.
+        /// </summary>
+        LargeTickHit
     }
 }

osu.Game/Scoring/Legacy/ScoreInfoExtensions.cs

@@ -12,7 +12,7 @@ namespace osu.Game.Scoring.Legacy
             switch (scoreInfo.Ruleset?.ID ?? scoreInfo.RulesetID)
             {
                 case 3:
-                    return scoreInfo.Statistics[HitResult.Perfect];
+                    return getCount(scoreInfo, HitResult.Perfect);
             }
 
             return null;
@@ -35,10 +35,10 @@ namespace osu.Game.Scoring.Legacy
                 case 0:
                 case 1:
                 case 3:
-                    return scoreInfo.Statistics[HitResult.Great];
+                    return getCount(scoreInfo, HitResult.Great);
 
                 case 2:
-                    return scoreInfo.Statistics[HitResult.Perfect];
+                    return getCount(scoreInfo, HitResult.Perfect);
             }
 
             return null;
@@ -65,7 +65,10 @@ namespace osu.Game.Scoring.Legacy
             switch (scoreInfo.Ruleset?.ID ?? scoreInfo.RulesetID)
             {
                 case 3:
-                    return scoreInfo.Statistics[HitResult.Good];
+                    return getCount(scoreInfo, HitResult.Good);
+
+                case 2:
+                    return getCount(scoreInfo, HitResult.SmallTickMiss);
             }
 
             return null;
@@ -78,6 +81,10 @@ namespace osu.Game.Scoring.Legacy
                 case 3:
                     scoreInfo.Statistics[HitResult.Good] = value;
                     break;
+
+                case 2:
+                    scoreInfo.Statistics[HitResult.SmallTickMiss] = value;
+                    break;
             }
         }
 
@@ -87,10 +94,13 @@ namespace osu.Game.Scoring.Legacy
             {
                 case 0:
                 case 1:
-                    return scoreInfo.Statistics[HitResult.Good];
+                    return getCount(scoreInfo, HitResult.Good);
 
                 case 3:
-                    return scoreInfo.Statistics[HitResult.Ok];
+                    return getCount(scoreInfo, HitResult.Ok);
+
+                case 2:
+                    return getCount(scoreInfo, HitResult.LargeTickHit);
             }
 
             return null;
@@ -108,6 +118,10 @@ namespace osu.Game.Scoring.Legacy
                 case 3:
                     scoreInfo.Statistics[HitResult.Ok] = value;
                     break;
+
+                case 2:
+                    scoreInfo.Statistics[HitResult.LargeTickHit] = value;
+                    break;
             }
         }
 
@@ -117,7 +131,10 @@ namespace osu.Game.Scoring.Legacy
             {
                 case 0:
                 case 3:
-                    return scoreInfo.Statistics[HitResult.Meh];
+                    return getCount(scoreInfo, HitResult.Meh);
+
+                case 2:
+                    return getCount(scoreInfo, HitResult.SmallTickHit);
             }
 
             return null;
@@ -131,13 +148,25 @@ namespace osu.Game.Scoring.Legacy
                 case 3:
                     scoreInfo.Statistics[HitResult.Meh] = value;
                     break;
+
+                case 2:
+                    scoreInfo.Statistics[HitResult.SmallTickHit] = value;
+                    break;
             }
         }
 
         public static int? GetCountMiss(this ScoreInfo scoreInfo) =>
-            scoreInfo.Statistics[HitResult.Miss];
+            getCount(scoreInfo, HitResult.Miss);
 
         public static void SetCountMiss(this ScoreInfo scoreInfo, int value) =>
             scoreInfo.Statistics[HitResult.Miss] = value;
+
+        private static int? getCount(ScoreInfo scoreInfo, HitResult result)
+        {
+            if (scoreInfo.Statistics.TryGetValue(result, out var existing))
+                return existing;
+
+            return null;
+        }
     }
 }

osu.Game/Screens/Play/BreakTracker.cs

@@ -2,40 +2,37 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Game.Beatmaps.Timing;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Utils;
 
 namespace osu.Game.Screens.Play
 {
     public class BreakTracker : Component
     {
         private readonly ScoreProcessor scoreProcessor;
-
         private readonly double gameplayStartTime;
 
+        private PeriodTracker breaks;
+
         /// <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 IReadOnlyList<BreakPeriod> breaks;
-
         public IReadOnlyList<BreakPeriod> Breaks
         {
-            get => breaks;
             set
             {
-                breaks = value;
-
-                // reset index in case the new breaks list is smaller than last one
                 isBreakTime.Value = false;
-                CurrentBreakIndex = 0;
+
+                breaks = new PeriodTracker(value.Where(b => b.HasEffect)
+                                                .Select(b => new Period(b.StartTime, b.EndTime - BreakOverlay.BREAK_FADE_DURATION)));
             }
         }
 
@@ -49,34 +46,11 @@ namespace osu.Game.Screens.Play
         {
             base.Update();
 
-            isBreakTime.Value = getCurrentBreak()?.HasEffect == true
-                                || Clock.CurrentTime < gameplayStartTime
-                                || scoreProcessor?.HasCompleted.Value == true;
-        }
-
-        private BreakPeriod getCurrentBreak()
-        {
-            if (breaks?.Count > 0)
-            {
             var time = Clock.CurrentTime;
 
-                if (time > breaks[CurrentBreakIndex].EndTime)
+            isBreakTime.Value = breaks?.IsInAny(time) == true
-                {
+                                || time < gameplayStartTime
-                    while (time > breaks[CurrentBreakIndex].EndTime && CurrentBreakIndex < breaks.Count - 1)
+                                || scoreProcessor?.HasCompleted.Value == true;
-                        CurrentBreakIndex++;
-                }
-                else
-                {
-                    while (time < breaks[CurrentBreakIndex].StartTime && CurrentBreakIndex > 0)
-                        CurrentBreakIndex--;
-                }
-
-                var closest = breaks[CurrentBreakIndex];
-
-                return closest.Contains(time) ? closest : null;
-            }
-
-            return null;
         }
     }
 }

osu.Game/Screens/Select/Carousel/CarouselBeatmap.cs

@@ -2,7 +2,6 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Screens.Select.Filter;
@@ -55,10 +54,7 @@ namespace osu.Game.Screens.Select.Carousel
 
             if (match)
             {
-                var terms = new List<string>();
+                var terms = Beatmap.SearchableTerms;
-
-                terms.AddRange(Beatmap.Metadata.SearchableTerms);
-                terms.Add(Beatmap.Version);
 
                 foreach (var criteriaTerm in criteria.SearchTerms)
                     match &= terms.Any(term => term.IndexOf(criteriaTerm, StringComparison.InvariantCultureIgnoreCase) >= 0);

osu.Game/Screens/Select/PlaySongSelect.cs

@@ -7,6 +7,7 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
 using osu.Framework.Screens;
 using osu.Game.Graphics;
+using osu.Game.Scoring;
 using osu.Game.Screens.Play;
 using osu.Game.Screens.Ranking;
 using osu.Game.Users;
@@ -32,9 +33,12 @@ namespace osu.Game.Screens.Select
                 Edit();
             }, Key.Number4);
 
-            ((PlayBeatmapDetailArea)BeatmapDetails).Leaderboard.ScoreSelected += score => this.Push(new ResultsScreen(score));
+            ((PlayBeatmapDetailArea)BeatmapDetails).Leaderboard.ScoreSelected += PresentScore;
         }
 
+        protected void PresentScore(ScoreInfo score) =>
+            FinaliseSelection(score.Beatmap, score.Ruleset, () => this.Push(new ResultsScreen(score)));
+
         protected override BeatmapDetailArea CreateBeatmapDetailArea() => new PlayBeatmapDetailArea();
 
         public override void OnResuming(IScreen last)

osu.Game/Screens/Select/SongSelect.cs

@@ -342,13 +342,17 @@ namespace osu.Game.Screens.Select
         /// Call to make a selection and perform the default action for this SongSelect.
         /// </summary>
         /// <param name="beatmap">An optional beatmap to override the current carousel selection.</param>
-        /// <param name="performStartAction">Whether to trigger <see cref="OnStart"/>.</param>
+        /// <param name="ruleset">An optional ruleset to override the current carousel selection.</param>
-        public void FinaliseSelection(BeatmapInfo beatmap = null, bool performStartAction = true)
+        /// <param name="customStartAction">An optional custom action to perform instead of <see cref="OnStart"/>.</param>
+        public void FinaliseSelection(BeatmapInfo beatmap = null, RulesetInfo ruleset = null, Action customStartAction = null)
         {
             // This is very important as we have not yet bound to screen-level bindables before the carousel load is completed.
             if (!Carousel.BeatmapSetsLoaded)
                 return;
 
+            if (ruleset != null)
+                Ruleset.Value = ruleset;
+
             transferRulesetValue();
 
             // while transferRulesetValue will flush, it only does so if the ruleset changes.
@@ -369,7 +373,12 @@ namespace osu.Game.Screens.Select
                 selectionChangedDebounce = null;
             }
 
-            if (performStartAction && OnStart())
+            if (customStartAction != null)
+            {
+                customStartAction();
+                Carousel.AllowSelection = false;
+            }
+            else if (OnStart())
                 Carousel.AllowSelection = false;
         }
 

osu.Game/Utils/PeriodTracker.cs

@@ -0,0 +1,69 @@
+// 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;
+
+namespace osu.Game.Utils
+{
+    /// <summary>
+    /// Represents a tracking component used for whether a specific time instant falls into any of the provided periods.
+    /// </summary>
+    public class PeriodTracker
+    {
+        private readonly List<Period> periods;
+        private int nearestIndex;
+
+        public PeriodTracker(IEnumerable<Period> periods)
+        {
+            this.periods = periods.OrderBy(period => period.Start).ToList();
+        }
+
+        /// <summary>
+        /// Whether the provided time is in any of the added periods.
+        /// </summary>
+        /// <param name="time">The time value to check.</param>
+        public bool IsInAny(double time)
+        {
+            if (periods.Count == 0)
+                return false;
+
+            if (time > periods[nearestIndex].End)
+            {
+                while (time > periods[nearestIndex].End && nearestIndex < periods.Count - 1)
+                    nearestIndex++;
+            }
+            else
+            {
+                while (time < periods[nearestIndex].Start && nearestIndex > 0)
+                    nearestIndex--;
+            }
+
+            var nearest = periods[nearestIndex];
+            return time >= nearest.Start && time <= nearest.End;
+        }
+    }
+
+    public readonly struct Period
+    {
+        /// <summary>
+        /// The start time of this period.
+        /// </summary>
+        public readonly double Start;
+
+        /// <summary>
+        /// The end time of this period.
+        /// </summary>
+        public readonly double End;
+
+        public Period(double start, double end)
+        {
+            if (start >= end)
+                throw new ArgumentException($"Invalid period provided, {nameof(start)} must be less than {nameof(end)}");
+
+            Start = start;
+            End = end;
+        }
+    }
+}

osu.Game/osu.Game.csproj

@@ -18,12 +18,13 @@
     </None>
   </ItemGroup>
   <ItemGroup Label="Package References">
+    <PackageReference Include="Dapper" Version="2.0.35" />
     <PackageReference Include="DiffPlex" Version="1.6.1" />
-    <PackageReference Include="Humanizer" Version="2.8.2" />
+    <PackageReference Include="Humanizer" Version="2.8.11" />
     <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.3" />
-    <PackageReference Include="ppy.osu.Framework" Version="2020.501.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2020.508.1" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.427.0" />
     <PackageReference Include="Sentry" Version="2.1.1" />
     <PackageReference Include="SharpCompress" Version="0.25.0" />

osu.iOS.props

@@ -70,17 +70,17 @@
     <Reference Include="System.Net.Http" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="ppy.osu.Framework.iOS" Version="2020.501.0" />
+    <PackageReference Include="ppy.osu.Framework.iOS" Version="2020.508.1" />
     <PackageReference Include="ppy.osu.Game.Resources" Version="2020.427.0" />
   </ItemGroup>
   <!-- Xamarin.iOS does not automatically handle transitive dependencies from NuGet packages. -->
   <ItemGroup Label="Transitive Dependencies">
     <PackageReference Include="DiffPlex" Version="1.6.1" />
-    <PackageReference Include="Humanizer" Version="2.8.2" />
+    <PackageReference Include="Humanizer" Version="2.8.11" />
     <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.3" />
-    <PackageReference Include="ppy.osu.Framework" Version="2020.501.0" />
+    <PackageReference Include="ppy.osu.Framework" Version="2020.508.1" />
     <PackageReference Include="SharpCompress" Version="0.25.0" />
     <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="SharpRaven" Version="2.4.0" />