Merge pull request #2124 from Poyo-SSB/mania-difficulty

Implement mania star difficulty calculation

osu.Game.Rulesets.Mania/ManiaDifficultyCalculator.cs

@@ -4,18 +4,142 @@
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.Beatmaps;
 using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mods;
+using System;
 using System.Collections.Generic;
 
 namespace osu.Game.Rulesets.Mania
 {
-    public class ManiaDifficultyCalculator : DifficultyCalculator<ManiaHitObject>
+    internal class ManiaDifficultyCalculator : DifficultyCalculator<ManiaHitObject>
     {
+        private const double star_scaling_factor = 0.018;
+
+        /// <summary>
+        /// In milliseconds. For difficulty calculation we will only look at the highest strain value in each time interval of size strain_step.
+        /// This is to eliminate higher influence of stream over aim by simply having more HitObjects with high strain.
+        /// The higher this value, the less strains there will be, indirectly giving long beatmaps an advantage.
+        /// </summary>
+        private const double strain_step = 400;
+
+        /// <summary>
+        /// The weighting of each strain value decays to this number * it's previous value
+        /// </summary>
+        private const double decay_weight = 0.9;
+
+        /// <summary>
+        /// HitObjects are stored as a member variable.
+        /// </summary>
+        private readonly List<ManiaHitObjectDifficulty> difficultyHitObjects = new List<ManiaHitObjectDifficulty>();
+
         public ManiaDifficultyCalculator(Beatmap beatmap)
             : base(beatmap)
         {
         }
 
-        public override double Calculate(Dictionary<string, double> categoryDifficulty = null) => 0;
+        public ManiaDifficultyCalculator(Beatmap beatmap, Mod[] mods)
+            : base(beatmap, mods)
+        {
+        }
+
+        public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
+        {
+            // Fill our custom DifficultyHitObject class, that carries additional information
+            difficultyHitObjects.Clear();
+
+            int columnCount = (Beatmap as ManiaBeatmap)?.TotalColumns ?? 7;
+
+            foreach (var hitObject in Beatmap.HitObjects)
+                difficultyHitObjects.Add(new ManiaHitObjectDifficulty(hitObject, columnCount));
+
+            // Sort DifficultyHitObjects by StartTime of the HitObjects - just to make sure.
+            difficultyHitObjects.Sort((a, b) => a.BaseHitObject.StartTime.CompareTo(b.BaseHitObject.StartTime));
+
+            if (!calculateStrainValues())
+                return 0;
+
+            double starRating = calculateDifficulty() * star_scaling_factor;
+
+            categoryDifficulty?.Add("Strain", starRating);
+
+            return starRating;
+        }
+
+        private bool calculateStrainValues()
+        {
+            // Traverse hitObjects in pairs to calculate the strain value of NextHitObject from the strain value of CurrentHitObject and environment.
+            using (List<ManiaHitObjectDifficulty>.Enumerator hitObjectsEnumerator = difficultyHitObjects.GetEnumerator())
+            {
+                if (!hitObjectsEnumerator.MoveNext())
+                    return false;
+
+                ManiaHitObjectDifficulty current = hitObjectsEnumerator.Current;
+
+                // First hitObject starts at strain 1. 1 is the default for strain values, so we don't need to set it here. See DifficultyHitObject.
+                while (hitObjectsEnumerator.MoveNext())
+                {
+                    var next = hitObjectsEnumerator.Current;
+                    next?.CalculateStrains(current, TimeRate);
+                    current = next;
+                }
+
+                return true;
+            }
+        }
+
+        private double calculateDifficulty()
+        {
+            double actualStrainStep = strain_step * TimeRate;
+
+            // Find the highest strain value within each strain step
+            List<double> highestStrains = new List<double>();
+            double intervalEndTime = actualStrainStep;
+            double maximumStrain = 0; // We need to keep track of the maximum strain in the current interval
+
+            ManiaHitObjectDifficulty previousHitObject = null;
+            foreach (var hitObject in difficultyHitObjects)
+            {
+                // While we are beyond the current interval push the currently available maximum to our strain list
+                while (hitObject.BaseHitObject.StartTime > intervalEndTime)
+                {
+                    highestStrains.Add(maximumStrain);
+
+                    // The maximum strain of the next interval is not zero by default! We need to take the last hitObject we encountered, take its strain and apply the decay
+                    // until the beginning of the next interval.
+                    if (previousHitObject == null)
+                    {
+                        maximumStrain = 0;
+                    }
+                    else
+                    {
+                        double individualDecay = Math.Pow(ManiaHitObjectDifficulty.INDIVIDUAL_DECAY_BASE, (intervalEndTime - previousHitObject.BaseHitObject.StartTime) / 1000);
+                        double overallDecay = Math.Pow(ManiaHitObjectDifficulty.OVERALL_DECAY_BASE, (intervalEndTime - previousHitObject.BaseHitObject.StartTime) / 1000);
+                        maximumStrain = previousHitObject.IndividualStrain * individualDecay + previousHitObject.OverallStrain * overallDecay;
+                    }
+
+                    // Go to the next time interval
+                    intervalEndTime += actualStrainStep;
+                }
+
+                // Obtain maximum strain
+                double strain = hitObject.IndividualStrain + hitObject.OverallStrain;
+                maximumStrain = Math.Max(strain, maximumStrain);
+
+                previousHitObject = hitObject;
+            }
+
+            // Build the weighted sum over the highest strains for each interval
+            double difficulty = 0;
+            double weight = 1;
+            highestStrains.Sort((a, b) => b.CompareTo(a)); // Sort from highest to lowest strain.
+
+            foreach (double strain in highestStrains)
+            {
+                difficulty += weight * strain;
+                weight *= decay_weight;
+            }
+
+            return difficulty;
+        }
 
         protected override BeatmapConverter<ManiaHitObject> CreateBeatmapConverter(Beatmap beatmap) => new ManiaBeatmapConverter(true, beatmap);
     }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -113,7 +113,7 @@ namespace osu.Game.Rulesets.Mania
 
         public override Drawable CreateIcon() => new SpriteIcon { Icon = FontAwesome.fa_osu_mania_o };
 
-        public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new ManiaDifficultyCalculator(beatmap);
+        public override DifficultyCalculator CreateDifficultyCalculator(Beatmap beatmap, Mod[] mods = null) => new ManiaDifficultyCalculator(beatmap, mods);
 
         public override int? LegacyID => 3;
 

osu.Game.Rulesets.Mania/Objects/ManiaHitObjectDifficulty.cs

@@ -0,0 +1,113 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Rulesets.Objects.Types;
+using System;
+
+namespace osu.Game.Rulesets.Mania.Objects
+{
+    internal class ManiaHitObjectDifficulty
+    {
+        /// <summary>
+        /// Factor by how much individual / overall strain decays per second.
+        /// </summary>
+        /// <remarks>
+        /// These values are results of tweaking a lot and taking into account general feedback.
+        /// </remarks>
+        internal const double INDIVIDUAL_DECAY_BASE = 0.125;
+        internal const double OVERALL_DECAY_BASE = 0.30;
+
+        internal ManiaHitObject BaseHitObject;
+
+        private readonly int beatmapColumnCount;
+
+
+        private readonly double endTime;
+        private readonly double[] heldUntil;
+
+        /// <summary>
+        ///  Measures jacks or more generally: repeated presses of the same button
+        /// </summary>
+        private readonly double[] individualStrains;
+
+        internal double IndividualStrain
+        {
+            get
+            {
+                return individualStrains[BaseHitObject.Column];
+            }
+
+            set
+            {
+                individualStrains[BaseHitObject.Column] = value;
+            }
+        }
+
+        /// <summary>
+        /// Measures note density in a way
+        /// </summary>
+        internal double OverallStrain = 1;
+
+        public ManiaHitObjectDifficulty(ManiaHitObject baseHitObject, int columnCount)
+        {
+            BaseHitObject = baseHitObject;
+
+            endTime = (baseHitObject as IHasEndTime)?.EndTime ?? baseHitObject.StartTime;
+
+            beatmapColumnCount = columnCount;
+            heldUntil = new double[beatmapColumnCount];
+            individualStrains = new double[beatmapColumnCount];
+
+            for (int i = 0; i < beatmapColumnCount; ++i)
+            {
+                individualStrains[i] = 0;
+                heldUntil[i] = 0;
+            }
+        }
+
+        internal void CalculateStrains(ManiaHitObjectDifficulty previousHitObject, double timeRate)
+        {
+            // TODO: Factor in holds
+            double timeElapsed = (BaseHitObject.StartTime - previousHitObject.BaseHitObject.StartTime) / timeRate;
+            double individualDecay = Math.Pow(INDIVIDUAL_DECAY_BASE, timeElapsed / 1000);
+            double overallDecay = Math.Pow(OVERALL_DECAY_BASE, timeElapsed / 1000);
+
+            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
+            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
+
+            // Fill up the heldUntil array
+            for (int i = 0; i < beatmapColumnCount; ++i)
+            {
+                heldUntil[i] = previousHitObject.heldUntil[i];
+
+                // If there is at least one other overlapping end or note, then we get an addition, buuuuuut...
+                if (BaseHitObject.StartTime < heldUntil[i] && endTime > heldUntil[i])
+                {
+                    holdAddition = 1.0;
+                }
+
+                // ... this addition only is valid if there is _no_ other note with the same ending. Releasing multiple notes at the same time is just as easy as releasing 1
+                if (endTime == heldUntil[i])
+                {
+                    holdAddition = 0;
+                }
+
+                // We give a slight bonus to everything if something is held meanwhile
+                if (heldUntil[i] > endTime)
+                {
+                    holdFactor = 1.25;
+                }
+
+                // Decay individual strains
+                individualStrains[i] = previousHitObject.individualStrains[i] * individualDecay;
+            }
+
+            heldUntil[BaseHitObject.Column] = endTime;
+
+            // Increase individual strain in own column
+            IndividualStrain += 2.0 * holdFactor;
+
+            OverallStrain = previousHitObject.OverallStrain * overallDecay + (1.0 + holdAddition) * holdFactor;
+        }
+    }
+}

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

@@ -115,6 +115,7 @@
     <Compile Include="Objects\Drawables\Pieces\GlowPiece.cs" />
     <Compile Include="Objects\Drawables\Pieces\LaneGlowPiece.cs" />
     <Compile Include="Objects\Drawables\Pieces\NotePiece.cs" />
+    <Compile Include="Objects\ManiaHitObjectDifficulty.cs" />
     <Compile Include="Objects\Types\IHasColumn.cs" />
     <Compile Include="Replays\ManiaAutoGenerator.cs" />
     <Compile Include="Replays\ManiaFramedReplayInputHandler.cs" />

osu.Game/Beatmaps/DifficultyCalculator.cs

@@ -24,9 +24,15 @@ namespace osu.Game.Beatmaps
 
         protected DifficultyCalculator(Beatmap beatmap, Mod[] mods = null)
         {
-            Beatmap = CreateBeatmapConverter(beatmap).Convert(beatmap);
             Mods = mods ?? new Mod[0];
 
+            var converter = CreateBeatmapConverter(beatmap);
+
+            foreach (var mod in Mods.OfType<IApplicableToBeatmapConverter<T>>())
+                mod.ApplyToBeatmapConverter(converter);
+
+            Beatmap = converter.Convert(beatmap);
+
             ApplyMods(Mods);
 
             PreprocessHitObjects();

osu.Game/Rulesets/Scoring/PerformanceCalculator.cs

@@ -2,7 +2,9 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
+using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 
 namespace osu.Game.Rulesets.Scoring
@@ -23,9 +25,15 @@ namespace osu.Game.Rulesets.Scoring
 
         protected PerformanceCalculator(Ruleset ruleset, Beatmap beatmap, Score score)
         {
-            Beatmap = CreateBeatmapConverter().Convert(beatmap);
             Score = score;
 
+            var converter = CreateBeatmapConverter();
+
+            foreach (var mod in score.Mods.OfType<IApplicableToBeatmapConverter<TObject>>())
+                mod.ApplyToBeatmapConverter(converter);
+
+            Beatmap = converter.Convert(beatmap);
+
             var diffCalc = ruleset.CreateDifficultyCalculator(beatmap, score.Mods);
             diffCalc.Calculate(attributes);
         }