h1or4dme8/osu-lazer
1
0
Fork 0
mirror of https://github.com/ppy/osu.git synced 2025-02-13 07:42:54 +08:00
Code Issues Releases Wiki Activity

Initial overlap calc

Browse Source
This commit is contained in:
Givikap120 2024-01-08 14:53:38 +02:00
parent ef3096123e
commit ffeb46af9b
3 changed files with 126 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
osu.Game.Rulesets.Osu/Difficulty/Evaluators/ReadingEvaluator.cs
View File

@ -8,6 +8,7 @@ using osu.Game.Rulesets.Difficulty.Preprocessing;
using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
using osu.Game.Rulesets.Osu.Mods;
using osu.Game.Rulesets.Osu.Objects;
using osuTK;
namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
{
@ -15,6 +16,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
{
private const double reading_window_size = 3000;
private const double hidden_multiplier = 0.0;
private const double density_multiplier = 0.0;
private const double overlap_multiplier = 25.0;
public static double EvaluateDifficultyOf(DifficultyHitObject current, bool hidden)
{
if (current.BaseObject is Spinner || current.Index == 0)
@ -27,6 +32,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
var clockRateEstimate = current.BaseObject.StartTime / currObj.StartTime;
double pastObjectDifficultyInfluence = 1.0;
double screenOverlapDifficulty = 0;
foreach (var loopObj in retrievePastVisibleObjects(currObj))
{
@ -39,8 +45,23 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
loopDifficulty *= getTimeNerfFactor(timeBetweenCurrAndLoopObj);
pastObjectDifficultyInfluence += loopDifficulty;
double lastOverlapness = 0;
foreach (var overlapObj in loopObj.OverlapObjects)
{
if (overlapObj.HitObject.StartTime + overlapObj.HitObject.Preempt > currObj.StartTime) break;
lastOverlapness = overlapObj.Overlapness;
}
screenOverlapDifficulty += lastOverlapness;
}
if (screenOverlapDifficulty > 0)
{
Console.WriteLine($"Object {currObj.StartTime}, overlapness = {screenOverlapDifficulty:0.##}");
}
// Console.WriteLine($"Object {currObj.StartTime}, overlapness = {overlapDifficulty:0.##}");
double noteDensityDifficulty = Math.Pow(4 * Math.Log(Math.Max(1, pastObjectDifficultyInfluence - 3)), 2.3);
double hiddenDifficulty = 0;
@ -56,7 +77,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
(8 + visibleObjectFactor) * currVelocity;
}
double difficulty = hiddenDifficulty + noteDensityDifficulty;
double difficulty = hidden_multiplier * hiddenDifficulty + density_multiplier * noteDensityDifficulty + overlap_multiplier * screenOverlapDifficulty;
// Console.WriteLine($"Object {currObj.StartTime}, {hiddenDifficulty:0.##} + {noteDensityDifficulty:0.##} + {overlapDifficulty:0.##}");
difficulty *= getConstantAngleNerfFactor(currObj);
return difficulty;
@ -139,11 +163,23 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
return Math.Pow(Math.Min(1, 2 / constantAngleCount), 2);
}
private static double getOverlapness(OsuDifficultyHitObject odho1, OsuDifficultyHitObject odho2)
{
OsuHitObject o1 = (OsuHitObject)odho1.BaseObject, o2 = (OsuHitObject)odho2.BaseObject;
double distance = Vector2.Distance(o1.StackedPosition, o2.StackedPosition);
if (distance > o1.Radius * 2)
return 0;
if (distance < o1.Radius)
return 1;
return 1 - Math.Pow((distance - o1.Radius) / o1.Radius, 2);
}
private static double getTimeNerfFactor(double deltaTime)
{
return Math.Clamp(2 - deltaTime / (reading_window_size / 2), 0, 1);
}
private static double logistic(double x) => 1 / (1 + Math.Pow(Math.E, -x));
private static double logistic(double x) => 1 / (1 + Math.Exp(-x));
}
}

18
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
View File

@ -104,6 +104,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double approachRateFactor = 0.0;
if (attributes.ApproachRate > 10.33)
approachRateFactor = 0.3 * (attributes.ApproachRate - 10.33);
// for testing
else if (attributes.ApproachRate < 8.0)
approachRateFactor = 0.05 * (8.0 - attributes.ApproachRate);
if (score.Mods.Any(h => h is OsuModRelax))
approachRateFactor = 0.0;
@ -112,6 +115,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (score.Mods.Any(m => m is OsuModBlinds))
aimValue *= 1.3 + (totalHits * (0.0016 / (1 + 2 * effectiveMissCount)) * Math.Pow(accuracy, 16)) * (1 - 0.003 * attributes.DrainRate * attributes.DrainRate);
// for testing
else if (score.Mods.Any(h => h is OsuModHidden))
{
// We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
aimValue *= 1.0 + 0.04 * (12.0 - attributes.ApproachRate);
}
// We assume 15% of sliders in a map are difficult since there's no way to tell from the performance calculator.
double estimateDifficultSliders = attributes.SliderCount * 0.15;
@ -158,6 +167,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
// Increasing the speed value by object count for Blinds isn't ideal, so the minimum buff is given.
speedValue *= 1.12;
}
// for testing
else if (score.Mods.Any(m => m is OsuModHidden))
{
// We want to give more reward for lower AR when it comes to aim and HD. This nerfs high AR and buffs lower AR.
speedValue *= 1.0 + 0.04 * (12.0 - attributes.ApproachRate);
}
// Calculate accuracy assuming the worst case scenario
double relevantTotalDiff = totalHits - attributes.SpeedNoteCount;
@ -203,6 +218,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
// Increasing the accuracy value by object count for Blinds isn't ideal, so the minimum buff is given.
if (score.Mods.Any(m => m is OsuModBlinds))
accuracyValue *= 1.14;
// For testing
else if (score.Mods.Any(m => m is OsuModHidden))
accuracyValue *= 1.08;
if (score.Mods.Any(m => m is OsuModFlashlight))
accuracyValue *= 1.02;

70
osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs
View File

@ -4,6 +4,8 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Channels;
using osu.Framework.Extensions.ObjectExtensions;
using osu.Game.Rulesets.Difficulty.Preprocessing;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Osu.Mods;
@ -83,6 +85,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
/// </summary>
public double HitWindowGreat { get; private set; }
/// <summary>
/// Objects that was visible after the note was hit together with cumulative overlapping difficulty.
/// </summary>
public IList<OverlapObject> OverlapObjects { get; private set; }
private readonly OsuHitObject? lastLastObject;
private readonly OsuHitObject lastObject;
public readonly double Preempt;
@ -107,6 +114,57 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
}
setDistances(clockRate);
OverlapObjects = new List<OverlapObject>();
double totalOverlapnessDifficulty = 0;
OsuDifficultyHitObject prevObject = this;
foreach (var loopObj in retrieveCurrentVisibleObjects(this))
{
double currentOverlapness = calculateOverlapness(this, loopObj); // overlapness with this object
double instantOverlapness = 0.5 + calculateOverlapness(prevObject, loopObj); // overlapness between current and prev to make streams have 0 buff
double angleFactor = 1;
if (loopObj.Angle != null) angleFactor += (-Math.Cos((double)loopObj.Angle) + 1) / 2; // =2 for wide angles, =1 for acute angles
instantOverlapness = Math.Min(1, instantOverlapness * angleFactor); // wide angles are more predictable
totalOverlapnessDifficulty += currentOverlapness * (1 - instantOverlapness); // wide angles will have close-to-zero buff
OverlapObjects.Add(new OverlapObject(loopObj, totalOverlapnessDifficulty));
prevObject = loopObj;
}
}
private static double calculateOverlapness(OsuDifficultyHitObject odho1, OsuDifficultyHitObject odho2)
{
OsuHitObject o1 = odho1.BaseObject, o2 = odho2.BaseObject;
double distance = Vector2.Distance(o1.StackedPosition, o2.StackedPosition);
if (distance > o1.Radius * 2)
return 0;
if (distance < o1.Radius)
return 1;
return 1 - Math.Pow((distance - o1.Radius) / o1.Radius, 2);
}
private static IEnumerable<OsuDifficultyHitObject> retrieveCurrentVisibleObjects(OsuDifficultyHitObject current)
{
for (int i = 0; i < current.Count; i++)
{
OsuDifficultyHitObject hitObject = (OsuDifficultyHitObject)current.Previous(i);
if (hitObject.IsNull() ||
// (hitObject.StartTime - current.StartTime) > reading_window_size ||
//current.StartTime < hitObject.StartTime - hitObject.Preempt)
hitObject.StartTime < current.StartTime - current.Preempt)
break;
yield return hitObject;
}
}
public double OpacityAt(double time, bool hidden)
@ -323,5 +381,17 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
return pos;
}
public struct OverlapObject
{
public OsuDifficultyHitObject HitObject;
public double Overlapness;
public OverlapObject(OsuDifficultyHitObject hitObject, double overlapness)
{
HitObject = hitObject;
Overlapness = overlapness;
}
}
}
}