Merge pull request #2593 from frankhjwx/catch_star_rating

Implement osu!catch star rating

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

@@ -0,0 +1,19 @@
+// 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.Difficulty;
+using osu.Game.Rulesets.Mods;
+
+namespace osu.Game.Rulesets.Catch.Difficulty
+{
+    public class CatchDifficultyAttributes : DifficultyAttributes
+    {
+        public double ApproachRate;
+        public int MaxCombo;
+
+        public CatchDifficultyAttributes(Mod[] mods, double starRating)
+            : base(mods, starRating)
+        {
+        }
+    }
+}

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

@@ -1,19 +1,146 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Difficulty;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
 
 namespace osu.Game.Rulesets.Catch.Difficulty
 {
     public class CatchDifficultyCalculator : DifficultyCalculator
     {
+
+        /// <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 = 750;
+
+        /// <summary>
+        /// The weighting of each strain value decays to this number * it's previous value
+        /// </summary>
+        private const double decay_weight = 0.94;
+
+        private const double star_scaling_factor = 0.145;
+
         public CatchDifficultyCalculator(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
         }
 
-        protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate) => new DifficultyAttributes(mods, 0);
+        protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate)
+        {
+            if (!beatmap.HitObjects.Any())
+                return new CatchDifficultyAttributes(mods, 0);
+
+            var catcher = new CatcherArea.Catcher(beatmap.BeatmapInfo.BaseDifficulty);
+            float halfCatchWidth = catcher.CatchWidth * 0.5f;
+
+            var difficultyHitObjects = new List<CatchDifficultyHitObject>();
+
+            foreach (var hitObject in beatmap.HitObjects)
+            {
+                // We want to only consider fruits that contribute to the combo. Droplets are addressed as accuracy and spinners are not relevant for "skill" calculations.
+                if (hitObject is Fruit)
+                {
+                    difficultyHitObjects.Add(new CatchDifficultyHitObject((CatchHitObject)hitObject, halfCatchWidth));
+                }
+                if (hitObject is JuiceStream)
+                    difficultyHitObjects.AddRange(hitObject.NestedHitObjects.OfType<CatchHitObject>().Where(o => !(o is TinyDroplet)).Select(o => new CatchDifficultyHitObject(o, halfCatchWidth)));
+            }
+
+            difficultyHitObjects.Sort((a, b) => a.BaseHitObject.StartTime.CompareTo(b.BaseHitObject.StartTime));
+
+            if (!calculateStrainValues(difficultyHitObjects, timeRate))
+                return new CatchDifficultyAttributes(mods, 0);
+
+            // this is the same as osu!, so there's potential to share the implementation... maybe
+            double preEmpt = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / timeRate;
+            double starRating = Math.Sqrt(calculateDifficulty(difficultyHitObjects, timeRate)) * star_scaling_factor;
+
+            return new CatchDifficultyAttributes(mods, starRating)
+            {
+                ApproachRate = preEmpt > 1200.0 ? -(preEmpt - 1800.0) / 120.0 : -(preEmpt - 1200.0) / 150.0 + 5.0,
+                MaxCombo = difficultyHitObjects.Count
+            };
+        }
+
+        private bool calculateStrainValues(List<CatchDifficultyHitObject> objects, double timeRate)
+        {
+            CatchDifficultyHitObject lastObject = null;
+
+            if (!objects.Any()) return false;
+
+            // Traverse hitObjects in pairs to calculate the strain value of NextHitObject from the strain value of CurrentHitObject and environment.
+            foreach (var currentObject in objects)
+            {
+                if (lastObject != null)
+                    currentObject.CalculateStrains(lastObject, timeRate);
+
+                lastObject = currentObject;
+            }
+
+            return true;
+        }
+
+        private double calculateDifficulty(List<CatchDifficultyHitObject> objects, double timeRate)
+        {
+            // The strain step needs to be adjusted for the algorithm to be considered equal with speed changing mods
+            double actualStrainStep = strain_step * timeRate;
+
+            // Find the highest strain value within each strain step
+            var highestStrains = new List<double>();
+            double intervalEndTime = actualStrainStep;
+            double maximumStrain = 0; // We need to keep track of the maximum strain in the current interval
+
+            CatchDifficultyHitObject previousHitObject = null;
+            foreach (CatchDifficultyHitObject hitObject in objects)
+            {
+                // 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 decay = Math.Pow(CatchDifficultyHitObject.DECAY_BASE, (intervalEndTime - previousHitObject.BaseHitObject.StartTime) / 1000);
+                        maximumStrain = previousHitObject.Strain * decay;
+                    }
+
+                    // Go to the next time interval
+                    intervalEndTime += actualStrainStep;
+                }
+
+                // Obtain maximum strain
+                maximumStrain = Math.Max(hitObject.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;
+        }
     }
 }

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

@@ -0,0 +1,130 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Catch.Difficulty
+{
+    public class CatchDifficultyHitObject
+    {
+        internal static readonly double DECAY_BASE = 0.20;
+        private const float normalized_hitobject_radius = 41.0f;
+        private const float absolute_player_positioning_error = 16f;
+        private readonly float playerPositioningError;
+
+        internal CatchHitObject BaseHitObject;
+
+        /// <summary>
+        /// Measures jump difficulty. CtB doesn't have something like button pressing speed or accuracy
+        /// </summary>
+        internal double Strain = 1;
+
+        /// <summary>
+        /// This is required to keep track of lazy player movement (always moving only as far as necessary)
+        /// Without this quick repeat sliders / weirdly shaped streams might become ridiculously overrated
+        /// </summary>
+        internal float PlayerPositionOffset;
+        internal float LastMovement;
+
+        internal float NormalizedPosition;
+        internal float ActualNormalizedPosition => NormalizedPosition + PlayerPositionOffset;
+
+        internal CatchDifficultyHitObject(CatchHitObject baseHitObject, float catcherWidthHalf)
+        {
+            BaseHitObject = baseHitObject;
+
+            // We will scale everything by this factor, so we can assume a uniform CircleSize among beatmaps.
+            float scalingFactor = normalized_hitobject_radius / catcherWidthHalf;
+
+            playerPositioningError = absolute_player_positioning_error; // * scalingFactor;
+            NormalizedPosition = baseHitObject.X * CatchPlayfield.BASE_WIDTH * scalingFactor;
+        }
+
+        private const double direction_change_bonus = 12.5;
+        internal void CalculateStrains(CatchDifficultyHitObject previousHitObject, double timeRate)
+        {
+            // Rather simple, but more specialized things are inherently inaccurate due to the big difference playstyles and opinions make.
+            // See Taiko feedback thread.
+            double timeElapsed = (BaseHitObject.StartTime - previousHitObject.BaseHitObject.StartTime) / timeRate;
+            double decay = Math.Pow(DECAY_BASE, timeElapsed / 1000);
+
+            // Update new position with lazy movement.
+            PlayerPositionOffset =
+                MathHelper.Clamp(
+                    previousHitObject.ActualNormalizedPosition,
+                    NormalizedPosition - (normalized_hitobject_radius - playerPositioningError),
+                    NormalizedPosition + (normalized_hitobject_radius - playerPositioningError)) // Obtain new lazy position, but be stricter by allowing for an error of a certain degree of the player.
+                - NormalizedPosition; // Subtract HitObject position to obtain offset
+
+            LastMovement = DistanceTo(previousHitObject);
+            double addition = spacingWeight(LastMovement);
+
+            if (NormalizedPosition < previousHitObject.NormalizedPosition)
+            {
+                LastMovement = -LastMovement;
+            }
+
+            CatchHitObject previousHitCircle = previousHitObject.BaseHitObject;
+
+            double additionBonus = 0;
+            double sqrtTime = Math.Sqrt(Math.Max(timeElapsed, 25));
+
+            // Direction changes give an extra point!
+            if (Math.Abs(LastMovement) > 0.1)
+            {
+                if (Math.Abs(previousHitObject.LastMovement) > 0.1 && Math.Sign(LastMovement) != Math.Sign(previousHitObject.LastMovement))
+                {
+                    double bonus = direction_change_bonus / sqrtTime;
+
+                    // Weight bonus by how
+                    double bonusFactor = Math.Min(playerPositioningError, Math.Abs(LastMovement)) / playerPositioningError;
+
+                    // We want time to play a role twice here!
+                    addition += bonus * bonusFactor;
+
+                    // Bonus for tougher direction switches and "almost" hyperdashes at this point
+                    if (previousHitCircle != null && previousHitCircle.DistanceToHyperDash <= 10.0f / CatchPlayfield.BASE_WIDTH)
+                    {
+                        additionBonus += 0.3 * bonusFactor;
+                    }
+                }
+
+                // Base bonus for every movement, giving some weight to streams.
+                addition += 7.5 * Math.Min(Math.Abs(LastMovement), normalized_hitobject_radius * 2) / (normalized_hitobject_radius * 6) / sqrtTime;
+            }
+
+            // Bonus for "almost" hyperdashes at corner points
+            if (previousHitCircle != null && previousHitCircle.DistanceToHyperDash <= 10.0f / CatchPlayfield.BASE_WIDTH)
+            {
+                if (!previousHitCircle.HyperDash)
+                {
+                    additionBonus += 1.0;
+                }
+                else
+                {
+                    // After a hyperdash we ARE in the correct position. Always!
+                    PlayerPositionOffset = 0;
+                }
+
+                addition *= 1.0 + additionBonus * ((10 - previousHitCircle.DistanceToHyperDash * CatchPlayfield.BASE_WIDTH) / 10);
+            }
+
+            addition *= 850.0 / Math.Max(timeElapsed, 25);
+
+            Strain = previousHitObject.Strain * decay + addition;
+        }
+
+        private static double spacingWeight(float distance)
+        {
+            return Math.Pow(distance, 1.3) / 500;
+        }
+
+        internal float DistanceTo(CatchDifficultyHitObject other)
+        {
+            return Math.Abs(ActualNormalizedPosition - other.ActualNormalizedPosition);
+        }
+    }
+}

osu.Game.Rulesets.Catch/Objects/CatchHitObject.cs

@@ -24,6 +24,11 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public int ComboIndex { get; set; }
 
+        /// <summary>
+        /// The distance for a fruit to to next hyper if it's not a hyper.
+        /// </summary>
+        public float DistanceToHyperDash { get; set; }
+
         /// <summary>
         /// The next fruit starts a new combo. Used for explodey.
         /// </summary>

osu.Game.Rulesets.Catch/UI/CatcherArea.cs

@@ -105,6 +105,11 @@ namespace osu.Game.Rulesets.Catch.UI
 
         public class Catcher : Container, IKeyBindingHandler<CatchAction>
         {
+            /// <summary>
+            /// Width of the area that can be used to attempt catches during gameplay.
+            /// </summary>
+            internal float CatchWidth => CATCHER_SIZE * Math.Abs(Scale.X);
+
             private Container<DrawableHitObject> caughtFruit;
 
             public Container ExplodingFruitTarget;
@@ -232,15 +237,15 @@ namespace osu.Game.Rulesets.Catch.UI
             /// <returns>Whether the catch is possible.</returns>
             public bool AttemptCatch(CatchHitObject fruit)
             {
-                double halfCatcherWidth = CATCHER_SIZE * Math.Abs(Scale.X) * 0.5f;
+                float halfCatchWidth = CatchWidth * 0.5f;
 
                 // this stuff wil disappear once we move fruit to non-relative coordinate space in the future.
                 var catchObjectPosition = fruit.X * CatchPlayfield.BASE_WIDTH;
                 var catcherPosition = Position.X * CatchPlayfield.BASE_WIDTH;
 
                 var validCatch =
-                    catchObjectPosition >= catcherPosition - halfCatcherWidth &&
-                    catchObjectPosition <= catcherPosition + halfCatcherWidth;
+                    catchObjectPosition >= catcherPosition - halfCatchWidth &&
+                    catchObjectPosition <= catcherPosition + halfCatchWidth;
 
                 if (validCatch && fruit.HyperDash)
                 {