Merge branch 'master' into ParallaxContainerImprovement

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

@@ -5,8 +5,6 @@ using System;
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.MathUtils;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Catch.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects;
@@ -14,7 +12,7 @@ using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
-    internal class CatchBeatmapConversionTest : BeatmapConversionTest<TestCatchRuleset, ConvertValue>
+    internal class CatchBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Catch";
 
@@ -47,7 +45,7 @@ namespace osu.Game.Rulesets.Catch.Tests
             }
         }
 
-        protected override IBeatmapConverter CreateConverter(IBeatmap beatmap) => new CatchBeatmapConverter(beatmap);
+        protected override Ruleset CreateRuleset() => new CatchRuleset();
     }
 
     internal struct ConvertValue : IEquatable<ConvertValue>
@@ -64,8 +62,4 @@ namespace osu.Game.Rulesets.Catch.Tests
             => Precision.AlmostEquals(StartTime, other.StartTime, conversion_lenience)
                && Precision.AlmostEquals(Position, other.Position, conversion_lenience);
     }
-
-    internal class TestCatchRuleset : CatchRuleset
-    {
-    }
 }

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

@@ -5,8 +5,6 @@ using System;
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.MathUtils;
-using osu.Game.Beatmaps;
-using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
@@ -14,7 +12,7 @@ using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
-    internal class ManiaBeatmapConversionTest : BeatmapConversionTest<TestManiaRuleset, ConvertValue>
+    internal class ManiaBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Mania";
 
@@ -35,7 +33,7 @@ namespace osu.Game.Rulesets.Mania.Tests
             };
         }
 
-        protected override IBeatmapConverter CreateConverter(IBeatmap beatmap) => new ManiaBeatmapConverter(beatmap);
+        protected override Ruleset CreateRuleset() => new ManiaRuleset();
     }
 
     internal struct ConvertValue : IEquatable<ConvertValue>
@@ -54,8 +52,4 @@ namespace osu.Game.Rulesets.Mania.Tests
                && Precision.AlmostEquals(EndTime, other.EndTime, conversion_lenience)
                && Column == other.Column;
     }
-
-    internal class TestManiaRuleset : ManiaRuleset
-    {
-    }
 }

osu.Game.Rulesets.Mania/Difficulty/ManiaDifficultyCalculator.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mania.Beatmaps;
@@ -49,11 +50,9 @@ namespace osu.Game.Rulesets.Mania.Difficulty
 
             int columnCount = (Beatmap as ManiaBeatmap)?.TotalColumns ?? 7;
 
-            foreach (var hitObject in Beatmap.HitObjects)
-                difficultyHitObjects.Add(new ManiaHitObjectDifficulty((ManiaHitObject)hitObject, columnCount));
-
             // Sort DifficultyHitObjects by StartTime of the HitObjects - just to make sure.
-            difficultyHitObjects.Sort((a, b) => a.BaseHitObject.StartTime.CompareTo(b.BaseHitObject.StartTime));
+            // Note: Stable sort is done so that the ordering of hitobjects with equal start times doesn't change
+            difficultyHitObjects.AddRange(Beatmap.HitObjects.Select(h => new ManiaHitObjectDifficulty((ManiaHitObject)h, columnCount)).OrderBy(h => h.BaseHitObject.StartTime));
 
             if (!calculateStrainValues())
                 return 0;

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

@@ -5,17 +5,15 @@ using System;
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.MathUtils;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Tests.Beatmaps;
 using OpenTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    internal class OsuBeatmapConversionTest : BeatmapConversionTest<TestOsuRuleset, ConvertValue>
+    internal class OsuBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Osu";
 
@@ -42,7 +40,7 @@ namespace osu.Game.Rulesets.Osu.Tests
             };
         }
 
-        protected override IBeatmapConverter CreateConverter(IBeatmap beatmap) => new OsuBeatmapConverter(beatmap);
+        protected override Ruleset CreateRuleset() => new OsuRuleset();
     }
 
     internal struct ConvertValue : IEquatable<ConvertValue>
@@ -67,8 +65,4 @@ namespace osu.Game.Rulesets.Osu.Tests
                && Precision.AlmostEquals(EndX, other.EndX, conversion_lenience)
                && Precision.AlmostEquals(EndY, other.EndY, conversion_lenience);
     }
-
-    internal class TestOsuRuleset : OsuRuleset
-    {
-    }
 }

osu.Game.Rulesets.Osu/Scoring/OsuPerformanceCalculator.cs

@@ -32,9 +32,9 @@ namespace osu.Game.Rulesets.Osu.Scoring
 
         private double accuracy;
         private int scoreMaxCombo;
-        private int count300;
+        private int countGreat;
-        private int count100;
+        private int countGood;
-        private int count50;
+        private int countMeh;
         private int countMiss;
 
         public OsuPerformanceCalculator(Ruleset ruleset, IBeatmap beatmap, Score score)
@@ -52,9 +52,9 @@ namespace osu.Game.Rulesets.Osu.Scoring
             mods = Score.Mods;
             accuracy = Score.Accuracy;
             scoreMaxCombo = Score.MaxCombo;
-            count300 = Convert.ToInt32(Score.Statistics[HitResult.Great]);
+            countGreat = Convert.ToInt32(Score.Statistics[HitResult.Great]);
-            count100 = Convert.ToInt32(Score.Statistics[HitResult.Good]);
+            countGood = Convert.ToInt32(Score.Statistics[HitResult.Good]);
-            count50 = Convert.ToInt32(Score.Statistics[HitResult.Meh]);
+            countMeh = Convert.ToInt32(Score.Statistics[HitResult.Meh]);
             countMiss = Convert.ToInt32(Score.Statistics[HitResult.Miss]);
 
             // Don't count scores made with supposedly unranked mods
@@ -71,10 +71,10 @@ namespace osu.Game.Rulesets.Osu.Scoring
                 ar = Math.Max(0, ar / 2);
 
             double preEmpt = BeatmapDifficulty.DifficultyRange(ar, 1800, 1200, 450) / TimeRate;
-            double hitWindow300 = (Beatmap.HitObjects.First().HitWindows.Great / 2 - 0.5) / TimeRate;
+            double hitWindowGreat = (Beatmap.HitObjects.First().HitWindows.Great / 2 - 0.5) / TimeRate;
 
             realApproachRate = preEmpt > 1200 ? (1800 - preEmpt) / 120 : (1200 - preEmpt) / 150 + 5;
-            realOverallDifficulty = (80 - 0.5 - hitWindow300) / 6;
+            realOverallDifficulty = (80 - 0.5 - hitWindowGreat) / 6;
 
             // Custom multipliers for NoFail and SpunOut.
             double multiplier = 1.12f; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things
@@ -190,7 +190,7 @@ namespace osu.Game.Rulesets.Osu.Scoring
             int amountHitObjectsWithAccuracy = countHitCircles;
 
             if (amountHitObjectsWithAccuracy > 0)
-                betterAccuracyPercentage = ((count300 - (totalHits - amountHitObjectsWithAccuracy)) * 6 + count100 * 2 + count50) / (amountHitObjectsWithAccuracy * 6);
+                betterAccuracyPercentage = ((countGreat - (totalHits - amountHitObjectsWithAccuracy)) * 6 + countGood * 2 + countMeh) / (amountHitObjectsWithAccuracy * 6);
             else
                 betterAccuracyPercentage = 0;
 
@@ -213,7 +213,7 @@ namespace osu.Game.Rulesets.Osu.Scoring
             return accuracyValue;
         }
 
-        private double totalHits => count300 + count100 + count50 + countMiss;
+        private double totalHits => countGreat + countGood + countMeh + countMiss;
-        private double totalSuccessfulHits => count300 + count100 + count50;
+        private double totalSuccessfulHits => countGreat + countGood + countMeh;
     }
 }

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

@@ -5,16 +5,14 @@ using System;
 using System.Collections.Generic;
 using NUnit.Framework;
 using osu.Framework.MathUtils;
-using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Taiko.Beatmaps;
 using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Tests.Beatmaps;
 
 namespace osu.Game.Rulesets.Taiko.Tests
 {
-    internal class TaikoBeatmapConversionTest : BeatmapConversionTest<TestTaikoRuleset, ConvertValue>
+    internal class TaikoBeatmapConversionTest : BeatmapConversionTest<ConvertValue>
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Taiko";
 
@@ -40,7 +38,7 @@ namespace osu.Game.Rulesets.Taiko.Tests
             };
         }
 
-        protected override IBeatmapConverter CreateConverter(IBeatmap beatmap) => new TaikoBeatmapConverter(beatmap);
+        protected override Ruleset CreateRuleset() => new TaikoRuleset();
     }
 
     internal struct ConvertValue : IEquatable<ConvertValue>
@@ -67,8 +65,4 @@ namespace osu.Game.Rulesets.Taiko.Tests
                && IsSwell == other.IsSwell
                && IsStrong == other.IsStrong;
     }
-
-    internal class TestTaikoRuleset : TaikoRuleset
-    {
-    }
 }

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -54,9 +54,11 @@ namespace osu.Game.Beatmaps.Formats
 
             base.ParseStreamInto(stream, beatmap);
 
-            // objects may be out of order *only* if a user has manually edited an .osu file.
+            // Objects may be out of order *only* if a user has manually edited an .osu file.
-            // unfortunately there are ranked maps in this state (example: https://osu.ppy.sh/s/594828).
+            // Unfortunately there are ranked maps in this state (example: https://osu.ppy.sh/s/594828).
-            this.beatmap.HitObjects.Sort((x, y) => x.StartTime.CompareTo(y.StartTime));
+            // OrderBy is used to guarantee that the parsing order of hitobjects with equal start times is maintained (stably-sorted)
+            // The parsing order of hitobjects matters in mania difficulty calculation
+            this.beatmap.HitObjects = this.beatmap.HitObjects.OrderBy(h => h.StartTime).ToList();
 
             foreach (var hitObject in this.beatmap.HitObjects)
                 hitObject.ApplyDefaults(this.beatmap.ControlPointInfo, this.beatmap.BeatmapInfo.BaseDifficulty);

osu.Game/Tests/Beatmaps/BeatmapConversionTest.cs

@@ -16,8 +16,7 @@ using osu.Game.Rulesets.Objects;
 namespace osu.Game.Tests.Beatmaps
 {
     [TestFixture]
-    public abstract class BeatmapConversionTest<TRuleset, TConvertValue>
+    public abstract class BeatmapConversionTest<TConvertValue>
-        where TRuleset : Ruleset, new()
         where TConvertValue : IEquatable<TConvertValue>
     {
         private const string resource_namespace = "Testing.Beatmaps";
@@ -81,12 +80,12 @@ namespace osu.Game.Tests.Beatmaps
         {
             var beatmap = getBeatmap(name);
 
-            var rulesetInstance = new TRuleset();
+            var rulesetInstance = CreateRuleset();
             beatmap.BeatmapInfo.Ruleset = beatmap.BeatmapInfo.RulesetID == rulesetInstance.RulesetInfo.ID ? rulesetInstance.RulesetInfo : new RulesetInfo();
 
             var result = new ConvertResult();
 
-            var converter = CreateConverter(beatmap);
+            var converter = rulesetInstance.CreateBeatmapConverter(beatmap);
             converter.ObjectConverted += (orig, converted) =>
             {
                 converted.ForEach(h => h.ApplyDefaults(beatmap.ControlPointInfo, beatmap.BeatmapInfo.BaseDifficulty));
@@ -130,7 +129,7 @@ namespace osu.Game.Tests.Beatmaps
         }
 
         protected abstract IEnumerable<TConvertValue> CreateConvertValue(HitObject hitObject);
-        protected abstract IBeatmapConverter CreateConverter(IBeatmap beatmap);
+        protected abstract Ruleset CreateRuleset();
 
         private class ConvertMapping
         {