2019-02-12 15:03:28 +08:00
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
2019-01-24 16:43:03 +08:00
// See the LICENCE file in the repository root for full licence text.
2018-04-13 17:19:50 +08:00
using System ;
using System.Linq ;
2019-02-12 15:03:28 +08:00
using osu.Game.Rulesets.Difficulty.Preprocessing ;
using osu.Game.Rulesets.Objects ;
2018-04-13 17:19:50 +08:00
using osu.Game.Rulesets.Osu.Objects ;
2018-11-20 15:51:59 +08:00
using osuTK ;
2018-04-13 17:19:50 +08:00
2018-05-15 16:36:29 +08:00
namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
2018-04-13 17:19:50 +08:00
{
2019-02-12 15:03:28 +08:00
public class OsuDifficultyHitObject : DifficultyHitObject
2018-04-13 17:19:50 +08:00
{
2021-09-25 11:02:33 +08:00
private const int normalized_radius = 50 ; // Change radius to 50 to make 100 the diameter. Easier for mental maths.
2021-10-22 00:00:57 +08:00
private const int min_delta_time = 25 ;
2018-05-15 20:44:45 +08:00
2019-02-12 15:03:28 +08:00
protected new OsuHitObject BaseObject = > ( OsuHitObject ) base . BaseObject ;
2018-04-13 17:19:50 +08:00
2021-09-15 18:24:48 +08:00
/// <summary>
2021-09-25 11:02:33 +08:00
/// Normalized distance from the end position of the previous <see cref="OsuDifficultyHitObject"/> to the start position of this <see cref="OsuDifficultyHitObject"/>.
2021-09-15 18:24:48 +08:00
/// </summary>
2021-09-25 11:02:33 +08:00
public double JumpDistance { get ; private set ; }
2021-09-15 18:24:48 +08:00
2018-04-13 17:19:50 +08:00
/// <summary>
2021-10-13 23:41:24 +08:00
/// Minimum distance from the end position of the previous <see cref="OsuDifficultyHitObject"/> to the start position of this <see cref="OsuDifficultyHitObject"/>.
2018-04-13 17:19:50 +08:00
/// </summary>
2021-10-13 23:41:24 +08:00
public double MovementDistance { get ; private set ; }
2018-10-08 16:37:33 +08:00
2021-10-22 00:00:57 +08:00
/// <summary>
2018-10-09 11:03:47 +08:00
/// Normalized distance between the start and end position of the previous <see cref="OsuDifficultyHitObject"/>.
2018-10-08 16:37:33 +08:00
/// </summary>
public double TravelDistance { get ; private set ; }
2018-04-13 17:19:50 +08:00
/// <summary>
2019-02-12 15:03:28 +08:00
/// Angle the player has to take to hit this <see cref="OsuDifficultyHitObject"/>.
/// Calculated as the angle between the circles (current-2, current-1, current).
2018-04-13 17:19:50 +08:00
/// </summary>
2019-02-12 15:03:28 +08:00
public double? Angle { get ; private set ; }
2018-04-13 17:19:50 +08:00
2021-10-13 23:41:24 +08:00
/// <summary>
/// Milliseconds elapsed since the end time of the Previous <see cref="OsuDifficultyHitObject"/>, with a minimum of 25ms.
/// </summary>
public double MovementTime { get ; private set ; }
/// <summary>
/// Milliseconds elapsed since from the start time of the Previous <see cref="OsuDifficultyHitObject"/> to the end time of the same Previous <see cref="OsuDifficultyHitObject"/>, with a minimum of 25ms.
/// </summary>
public double TravelTime { get ; private set ; }
2021-09-25 11:02:33 +08:00
/// <summary>
2021-09-27 09:39:57 +08:00
/// Milliseconds elapsed since the start time of the previous <see cref="OsuDifficultyHitObject"/>, with a minimum of 25ms.
2021-09-25 11:02:33 +08:00
/// </summary>
public readonly double StrainTime ;
2018-12-09 19:42:27 +08:00
private readonly OsuHitObject lastLastObject ;
2018-05-15 20:22:57 +08:00
private readonly OsuHitObject lastObject ;
2018-04-13 17:19:50 +08:00
2019-02-19 16:43:12 +08:00
public OsuDifficultyHitObject ( HitObject hitObject , HitObject lastLastObject , HitObject lastObject , double clockRate )
: base ( hitObject , lastObject , clockRate )
2018-04-13 17:19:50 +08:00
{
2019-02-12 15:03:28 +08:00
this . lastLastObject = ( OsuHitObject ) lastLastObject ;
this . lastObject = ( OsuHitObject ) lastObject ;
2018-05-15 20:22:57 +08:00
2021-09-15 22:27:36 +08:00
// Capped to 25ms to prevent difficulty calculation breaking from simulatenous objects.
2021-10-22 00:00:57 +08:00
StrainTime = Math . Max ( DeltaTime , min_delta_time ) ;
2021-10-13 23:41:24 +08:00
setDistances ( clockRate ) ;
2018-04-13 17:19:50 +08:00
}
2021-10-13 23:41:24 +08:00
private void setDistances ( double clockRate )
2018-04-13 17:19:50 +08:00
{
2021-10-10 02:11:24 +08:00
// We don't need to calculate either angle or distance when one of the last->curr objects is a spinner
2021-10-10 01:28:42 +08:00
if ( BaseObject is Spinner | | lastObject is Spinner )
return ;
2018-04-13 17:19:50 +08:00
// We will scale distances by this factor, so we can assume a uniform CircleSize among beatmaps.
2018-10-08 16:37:33 +08:00
float scalingFactor = normalized_radius / ( float ) BaseObject . Radius ;
2019-04-01 11:16:05 +08:00
2018-04-13 17:19:50 +08:00
if ( BaseObject . Radius < 30 )
{
2018-12-21 21:52:27 +08:00
float smallCircleBonus = Math . Min ( 30 - ( float ) BaseObject . Radius , 5 ) / 50 ;
2018-04-13 17:19:50 +08:00
scalingFactor * = 1 + smallCircleBonus ;
}
2018-12-09 19:42:27 +08:00
if ( lastObject is Slider lastSlider )
2018-12-23 15:26:23 +08:00
{
computeSliderCursorPosition ( lastSlider ) ;
2021-10-22 00:08:35 +08:00
TravelDistance = 0 ;
2021-10-22 00:00:57 +08:00
TravelTime = Math . Max ( lastSlider . LazyTravelTime / clockRate , min_delta_time ) ;
2021-10-22 05:30:00 +08:00
MovementTime = Math . Max ( StrainTime - lastSlider . LazyTravelTime / clockRate , min_delta_time ) ;
2021-10-14 00:04:39 +08:00
MovementDistance = Vector2 . Subtract ( lastSlider . TailCircle . StackedPosition , BaseObject . StackedPosition ) . Length * scalingFactor ;
2021-10-22 00:08:35 +08:00
int repeatCount = 0 ;
for ( int i = 1 ; i < lastSlider . NestedHitObjects . Count ; i + + )
{
if ( ( OsuHitObject ) lastSlider . NestedHitObjects [ i ] is SliderRepeat )
repeatCount + + ;
Vector2 currSlider = Vector2 . Subtract ( ( ( OsuHitObject ) lastSlider . NestedHitObjects [ i ] ) . StackedPosition , ( ( OsuHitObject ) lastSlider . NestedHitObjects [ i - 1 ] ) . StackedPosition ) ;
2021-10-22 00:14:31 +08:00
if ( ( OsuHitObject ) lastSlider . NestedHitObjects [ i ] is SliderEndCircle | | ( OsuHitObject ) lastSlider . NestedHitObjects [ i ] is SliderRepeat )
2021-10-22 00:08:35 +08:00
TravelDistance + = Math . Max ( 0 , currSlider . Length * scalingFactor - 100 ) ;
else
TravelDistance + = Vector2 . Subtract ( ( ( OsuHitObject ) lastSlider . NestedHitObjects [ i ] ) . StackedPosition , ( ( OsuHitObject ) lastSlider . NestedHitObjects [ i - 1 ] ) . StackedPosition ) . Length * scalingFactor ;
2021-10-22 00:14:31 +08:00
if ( ( OsuHitObject ) lastSlider . NestedHitObjects [ i ] is SliderTick & & i ! = lastSlider . NestedHitObjects . Count - 1 ) // Check for tick && not last object is necessary for 2007 bugged sliders.
2021-10-22 00:08:35 +08:00
{
Vector2 nextSlider = Vector2 . Subtract ( ( ( OsuHitObject ) lastSlider . NestedHitObjects [ i + 1 ] ) . StackedPosition , ( ( OsuHitObject ) lastSlider . NestedHitObjects [ i ] ) . StackedPosition ) ;
2021-10-22 03:58:02 +08:00
TravelDistance + = 3 * Math . Max ( 0 , Vector2 . Subtract ( nextSlider , currSlider ) . Length - Math . Max ( nextSlider . Length , currSlider . Length ) ) * scalingFactor ;
2021-10-22 00:08:35 +08:00
}
}
2021-10-22 05:30:00 +08:00
TravelDistance * = Math . Pow ( 1 + repeatCount , 1.0 / 3.0 ) ;
TravelDistance * = Math . Max ( 0 , lastSlider . SpanDuration - 37.5 ) / lastSlider . SpanDuration ;
2018-12-23 15:26:23 +08:00
}
2018-12-09 19:42:27 +08:00
Vector2 lastCursorPosition = getEndCursorPosition ( lastObject ) ;
2018-04-13 17:19:50 +08:00
2021-10-22 00:00:57 +08:00
JumpDistance = ( BaseObject . StackedPosition * scalingFactor - lastCursorPosition * scalingFactor ) . Length ;
2021-10-22 05:30:00 +08:00
MovementDistance = Math . Max ( 0 , Math . Min ( JumpDistance , MovementDistance ) - 50 ) ;
2018-12-08 14:01:26 +08:00
2021-10-10 01:28:42 +08:00
if ( lastLastObject ! = null & & ! ( lastLastObject is Spinner ) )
2018-12-08 14:01:26 +08:00
{
2018-12-09 19:42:27 +08:00
Vector2 lastLastCursorPosition = getEndCursorPosition ( lastLastObject ) ;
2018-12-08 14:01:26 +08:00
2018-12-09 19:42:27 +08:00
Vector2 v1 = lastLastCursorPosition - lastObject . StackedPosition ;
Vector2 v2 = BaseObject . StackedPosition - lastCursorPosition ;
2018-12-08 14:01:26 +08:00
float dot = Vector2 . Dot ( v1 , v2 ) ;
float det = v1 . X * v2 . Y - v1 . Y * v2 . X ;
2018-12-09 19:31:04 +08:00
Angle = Math . Abs ( Math . Atan2 ( det , dot ) ) ;
2018-12-08 14:01:26 +08:00
}
2018-04-13 17:19:50 +08:00
}
private void computeSliderCursorPosition ( Slider slider )
{
if ( slider . LazyEndPosition ! = null )
return ;
2019-02-28 12:31:40 +08:00
2018-10-11 12:53:29 +08:00
slider . LazyEndPosition = slider . StackedPosition ;
2018-04-13 17:19:50 +08:00
2021-10-22 00:00:57 +08:00
float followCircleRadius = ( float ) ( slider . Radius * 2.4 ) ;
2018-04-13 17:19:50 +08:00
var computeVertex = new Action < double > ( t = >
{
2019-01-15 18:07:25 +08:00
double progress = ( t - slider . StartTime ) / slider . SpanDuration ;
if ( progress % 2 > = 1 )
2018-10-08 17:37:30 +08:00
progress = 1 - progress % 1 ;
else
2019-11-12 17:56:38 +08:00
progress % = 1 ;
2018-10-08 17:37:30 +08:00
2018-04-13 17:19:50 +08:00
// ReSharper disable once PossibleInvalidOperationException (bugged in current r# version)
2018-11-01 02:52:24 +08:00
var diff = slider . StackedPosition + slider . Path . PositionAt ( progress ) - slider . LazyEndPosition . Value ;
2018-04-13 17:19:50 +08:00
float dist = diff . Length ;
2021-10-13 23:41:24 +08:00
slider . LazyTravelTime = t - slider . StartTime ;
2021-10-22 00:00:57 +08:00
if ( dist > followCircleRadius )
2018-04-13 17:19:50 +08:00
{
// The cursor would be outside the follow circle, we need to move it
diff . Normalize ( ) ; // Obtain direction of diff
2021-10-22 00:00:57 +08:00
dist - = followCircleRadius ;
2018-04-13 17:19:50 +08:00
slider . LazyEndPosition + = diff * dist ;
slider . LazyTravelDistance + = dist ;
}
} ) ;
2018-05-15 20:25:33 +08:00
// Skip the head circle
var scoringTimes = slider . NestedHitObjects . Skip ( 1 ) . Select ( t = > t . StartTime ) ;
2018-04-13 17:19:50 +08:00
foreach ( var time in scoringTimes )
computeVertex ( time ) ;
}
2018-12-09 19:42:27 +08:00
private Vector2 getEndCursorPosition ( OsuHitObject hitObject )
{
Vector2 pos = hitObject . StackedPosition ;
2019-02-28 13:35:00 +08:00
if ( hitObject is Slider slider )
2018-12-09 19:42:27 +08:00
{
computeSliderCursorPosition ( slider ) ;
pos = slider . LazyEndPosition ? ? pos ;
}
return pos ;
}
2018-04-13 17:19:50 +08:00
}
}