sim1222/osukey
1
1
Fork 0
mirror of https://github.com/osukey/osukey.git synced 2025-08-04 23:24:04 +09:00
Code Issues Packages Projects Releases Wiki Activity

Refactor drain calculation for resiliency

Browse Source
This commit is contained in:
smoogipoo
2019-12-26 17:36:40 +09:00
parent 662ec2d812
commit f5dbd57d55
1 changed files with 47 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
osu.Game/Rulesets/Scoring/DrainingHealthProcessor.cs
View File

@ -14,8 +14,12 @@ namespace osu.Game.Rulesets.Scoring
/// </summary> /// </summary>
public class DrainingHealthProcessor : HealthProcessor public class DrainingHealthProcessor : HealthProcessor
{ {
private IBeatmap beatmap; /// <summary>
/// A reasonable allowable error for the minimum health offset from <see cref="targetMinimumHealth"/>. A 1% error is unnoticeable.
/// </summary>
private const double minimum_health_error = 0.01;
private IBeatmap beatmap;
private double gameplayEndTime; private double gameplayEndTime;
private List<(double time, double health)> healthIncreases; private List<(double time, double health)> healthIncreases;
@ -74,10 +78,20 @@ namespace osu.Game.Rulesets.Scoring
drainRate = 1; drainRate = 1;
if (storeResults) if (storeResults)
{ drainRate = computeDrainRate();
int count = 1; }
while (true) private double computeDrainRate()
{
if (healthIncreases == null || healthIncreases.Count == 0)
return 0;
int adjustment = 1;
double result = 1;
// Although we expect the following loop to converge within 30 iterations (health within 1/2^31 accuracy of the target),
// we'll still keep a safety measure to avoid infinite loops by detecting overflows.
while (adjustment > 0)
{ {
double currentHealth = 1; double currentHealth = 1;
double lowestHealth = 1; double lowestHealth = 1;
@ -99,7 +113,7 @@ namespace osu.Game.Rulesets.Scoring
} }
// Apply health adjustments // Apply health adjustments
currentHealth -= (healthIncreases[i].time - lastTime) * drainRate; currentHealth -= (healthIncreases[i].time - lastTime) * result;
lowestHealth = Math.Min(lowestHealth, currentHealth); lowestHealth = Math.Min(lowestHealth, currentHealth);
currentHealth = Math.Min(1, currentHealth + healthIncreases[i].health); currentHealth = Math.Min(1, currentHealth + healthIncreases[i].health);
@ -108,15 +122,16 @@ namespace osu.Game.Rulesets.Scoring
break; break;
} }
if (Math.Abs(lowestHealth - targetMinimumHealth) <= 0.01) // Stop if the resulting health is within a reasonable offset from the target
if (Math.Abs(lowestHealth - targetMinimumHealth) <= minimum_health_error)
break; break;
count *= 2; // This effectively works like a binary search - each iteration the search space moves closer to the the target, but may exceed it.
drainRate += 1.0 / count * Math.Sign(lowestHealth - targetMinimumHealth); adjustment *= 2;
} result += 1.0 / adjustment * Math.Sign(lowestHealth - targetMinimumHealth);
} }
healthIncreases.Clear(); return result;
} }
} }
} }