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>
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 List<(double time, double health)> healthIncreases;
@ -74,10 +78,20 @@ namespace osu.Game.Rulesets.Scoring
drainRate = 1;
if (storeResults)
{
int count = 1;
drainRate = computeDrainRate();
}
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 lowestHealth = 1;
@ -99,7 +113,7 @@ namespace osu.Game.Rulesets.Scoring
}
// Apply health adjustments
currentHealth -= (healthIncreases[i].time - lastTime) * drainRate;
currentHealth -= (healthIncreases[i].time - lastTime) * result;
lowestHealth = Math.Min(lowestHealth, currentHealth);
currentHealth = Math.Min(1, currentHealth + healthIncreases[i].health);
@ -108,15 +122,16 @@ namespace osu.Game.Rulesets.Scoring
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;
count *= 2;
drainRate += 1.0 / count * Math.Sign(lowestHealth - targetMinimumHealth);
}
// This effectively works like a binary search - each iteration the search space moves closer to the the target, but may exceed it.
adjustment *= 2;
result += 1.0 / adjustment * Math.Sign(lowestHealth - targetMinimumHealth);
}
healthIncreases.Clear();
return result;
}
}
}