From cff9dab650b8bc0e453be6b312a96b778fdcbc93 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Tue, 14 Dec 2021 03:11:04 +0000
Subject: [PATCH 001/924] Remove combo scaling and change miss penalty
---
.../Difficulty/OsuPerformanceCalculator.cs | 17 +++--------------
1 file changed, 3 insertions(+), 14 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 8d45c7a8cc..6de6572b93 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -101,13 +101,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
aimValue *= lengthBonus;
- // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
if (effectiveMissCount > 0)
- aimValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), effectiveMissCount);
-
- // Combo scaling.
- if (Attributes.MaxCombo > 0)
- aimValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
+ aimValue *= Math.Pow(0.97, effectiveMissCount);
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
@@ -151,13 +146,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
(totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
speedValue *= lengthBonus;
- // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
if (effectiveMissCount > 0)
- speedValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
-
- // Combo scaling.
- if (Attributes.MaxCombo > 0)
- speedValue *= Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
+ speedValue *= Math.Pow(0.97, effectiveMissCount);
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
@@ -238,9 +228,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (mods.Any(h => h is OsuModHidden))
flashlightValue *= 1.3;
- // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
if (effectiveMissCount > 0)
- flashlightValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
+ flashlightValue *= Math.Pow(0.97, effectiveMissCount);
// Combo scaling.
if (Attributes.MaxCombo > 0)
From 86ad42a7440ec0a1478e2030209c2675985e3220 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Tue, 14 Dec 2021 17:47:41 +0000
Subject: [PATCH 002/924] Nerf length bonus
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 6de6572b93..6ade8c1732 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -96,7 +96,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double aimValue = Math.Pow(5.0 * Math.Max(1.0, rawAim / 0.0675) - 4.0, 3.0) / 100000.0;
// Longer maps are worth more.
- double lengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
+ double lengthBonus = 0.95 + 0.25 * Math.Min(1.0, totalHits / 2000.0) +
(totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
aimValue *= lengthBonus;
@@ -142,7 +142,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double speedValue = Math.Pow(5.0 * Math.Max(1.0, Attributes.SpeedStrain / 0.0675) - 4.0, 3.0) / 100000.0;
// Longer maps are worth more.
- double lengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
+ double lengthBonus = 0.95 + 0.25 * Math.Min(1.0, totalHits / 2000.0) +
(totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
speedValue *= lengthBonus;
From 489aa43b1bab6efeb0ed05e97ec66181dfe3b4f4 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Tue, 14 Dec 2021 19:57:36 +0000
Subject: [PATCH 003/924] Make miss penalty harsher
---
.../Difficulty/OsuPerformanceCalculator.cs | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 6ade8c1732..0459c64c0e 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -96,13 +96,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double aimValue = Math.Pow(5.0 * Math.Max(1.0, rawAim / 0.0675) - 4.0, 3.0) / 100000.0;
// Longer maps are worth more.
- double lengthBonus = 0.95 + 0.25 * Math.Min(1.0, totalHits / 2000.0) +
+ double lengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
(totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
aimValue *= lengthBonus;
if (effectiveMissCount > 0)
- aimValue *= Math.Pow(0.97, effectiveMissCount);
+ aimValue *= Math.Pow(0.96, effectiveMissCount);
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
@@ -142,12 +142,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double speedValue = Math.Pow(5.0 * Math.Max(1.0, Attributes.SpeedStrain / 0.0675) - 4.0, 3.0) / 100000.0;
// Longer maps are worth more.
- double lengthBonus = 0.95 + 0.25 * Math.Min(1.0, totalHits / 2000.0) +
+ double lengthBonus = 0.95 + 0.4 * Math.Min(1.0, totalHits / 2000.0) +
(totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
speedValue *= lengthBonus;
if (effectiveMissCount > 0)
- speedValue *= Math.Pow(0.97, effectiveMissCount);
+ speedValue *= Math.Pow(0.96, effectiveMissCount);
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
@@ -229,7 +229,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
flashlightValue *= 1.3;
if (effectiveMissCount > 0)
- flashlightValue *= Math.Pow(0.97, effectiveMissCount);
+ flashlightValue *= Math.Pow(0.96, effectiveMissCount);
// Combo scaling.
if (Attributes.MaxCombo > 0)
From bac4cfed50be4e3d1e0264ce0cd9099c3132d4b5 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Thu, 16 Dec 2021 18:37:57 +0000
Subject: [PATCH 004/924] Use frost's miss count penalty
---
.../Difficulty/OsuPerformanceCalculator.cs | 21 ++++++++++++++++---
1 file changed, 18 insertions(+), 3 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 0459c64c0e..bba53c92fc 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -102,7 +102,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
aimValue *= lengthBonus;
if (effectiveMissCount > 0)
- aimValue *= Math.Pow(0.96, effectiveMissCount);
+ aimValue *= calculateMissPenalty(effectiveMissCount);
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
@@ -147,7 +147,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
speedValue *= lengthBonus;
if (effectiveMissCount > 0)
- speedValue *= Math.Pow(0.96, effectiveMissCount);
+ speedValue *= calculateMissPenalty(effectiveMissCount);
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
@@ -229,7 +229,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
flashlightValue *= 1.3;
if (effectiveMissCount > 0)
- flashlightValue *= Math.Pow(0.96, effectiveMissCount);
+ flashlightValue *= calculateMissPenalty(effectiveMissCount);
// Combo scaling.
if (Attributes.MaxCombo > 0)
@@ -265,6 +265,21 @@ namespace osu.Game.Rulesets.Osu.Difficulty
return Math.Max(countMiss, (int)Math.Floor(comboBasedMissCount));
}
+ private double calculateMissPenalty(double missCount)
+ {
+ double leniency = 2.0;
+
+ if (missCount > totalHits - leniency)
+ return 0;
+
+ double missApprox = erfInvApprox((totalHits - leniency - missCount) / totalHits);
+ double fcApprox = erfInvApprox((totalHits - leniency) / totalHits);
+
+ return Math.Pow(missApprox / fcApprox, 1.5);
+ }
+
+ private double logit(double x) => Math.Log(x / (1 - x));
+ private double erfInvApprox(double x) => (Math.Sqrt(Math.PI) / 4) * logit((x + 1) / 2);
private int totalHits => countGreat + countOk + countMeh + countMiss;
private int totalSuccessfulHits => countGreat + countOk + countMeh;
}
From 60e2a8ed4b2f0f38dafe0cc9bc6ab8c55128b189 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Tue, 21 Dec 2021 17:54:26 +0000
Subject: [PATCH 005/924] Use MathNet for miss penalty calculation, and use old
penalty formula for Flashlight
---
.../Difficulty/OsuPerformanceCalculator.cs | 14 +++++++-------
osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj | 4 ++++
2 files changed, 11 insertions(+), 7 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index bba53c92fc..90caa64512 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -9,6 +9,7 @@ using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Osu.Mods;
using osu.Game.Rulesets.Scoring;
using osu.Game.Scoring;
+using MathNet.Numerics;
namespace osu.Game.Rulesets.Osu.Difficulty
{
@@ -228,8 +229,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (mods.Any(h => h is OsuModHidden))
flashlightValue *= 1.3;
+ // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
if (effectiveMissCount > 0)
- flashlightValue *= calculateMissPenalty(effectiveMissCount);
+ flashlightValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
// Combo scaling.
if (Attributes.MaxCombo > 0)
@@ -267,19 +269,17 @@ namespace osu.Game.Rulesets.Osu.Difficulty
private double calculateMissPenalty(double missCount)
{
- double leniency = 2.0;
+ double leniency = 4.3;
if (missCount > totalHits - leniency)
return 0;
- double missApprox = erfInvApprox((totalHits - leniency - missCount) / totalHits);
- double fcApprox = erfInvApprox((totalHits - leniency) / totalHits);
+ double missApprox = SpecialFunctions.ErfInv((totalHits - leniency - missCount) / totalHits);
+ double fcApprox = SpecialFunctions.ErfInv((totalHits - leniency) / totalHits);
- return Math.Pow(missApprox / fcApprox, 1.5);
+ return Math.Pow(missApprox / fcApprox, 3.5);
}
- private double logit(double x) => Math.Log(x / (1 - x));
- private double erfInvApprox(double x) => (Math.Sqrt(Math.PI) / 4) * logit((x + 1) / 2);
private int totalHits => countGreat + countOk + countMeh + countMiss;
private int totalSuccessfulHits => countGreat + countOk + countMeh;
}
diff --git a/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj b/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj
index 98f1e69bd1..018bdb93df 100644
--- a/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj
+++ b/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj
@@ -15,4 +15,8 @@
+
+
+
+
\ No newline at end of file
From 5640918c8c7c8af2e29feec4c7ad6d501619dafc Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Sun, 26 Dec 2021 23:51:49 +0000
Subject: [PATCH 006/924] New miss penalty formula, using relevant difficult
notes in each skill (targets diffspikes)
---
.../Difficulty/OsuDifficultyAttributes.cs | 6 ++++++
.../Difficulty/OsuDifficultyCalculator.cs | 9 +++++++++
.../Difficulty/OsuPerformanceCalculator.cs | 16 ++++------------
.../Difficulty/Skills/OsuStrainSkill.cs | 7 +++++++
4 files changed, 26 insertions(+), 12 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
index 4b2e54da17..6102f4a8b2 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
@@ -24,6 +24,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
[JsonProperty("slider_factor")]
public double SliderFactor { get; set; }
+ [JsonProperty("aim_difficult_strain_count")]
+ public int AimDifficultStrainCount { get; set; }
+
+ [JsonProperty("speed_difficult_strain_count")]
+ public int SpeedDifficultStrainCount { get; set; }
+
[JsonProperty("approach_rate")]
public double ApproachRate { get; set; }
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
index ed42f333c0..ac228b0a32 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
@@ -40,6 +40,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;
+ int aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).RelevantDifficultStrains();
+ int speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).RelevantDifficultStrains();
+
+ // Total number of strains in a map can vary by clockrate, and this needs to be corrected for.
+ aimDifficultyStrainCount = (int)(aimDifficultyStrainCount * clockRate);
+ speedDifficultyStrainCount = (int)(aimDifficultyStrainCount * clockRate);
+
if (mods.Any(h => h is OsuModRelax))
speedRating = 0.0;
@@ -78,6 +85,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
SpeedStrain = speedRating,
FlashlightRating = flashlightRating,
SliderFactor = sliderFactor,
+ AimDifficultStrainCount = aimDifficultyStrainCount,
+ SpeedDifficultStrainCount = speedDifficultyStrainCount,
ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5,
OverallDifficulty = (80 - hitWindowGreat) / 6,
DrainRate = drainRate,
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 90caa64512..3efb8951b3 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
aimValue *= lengthBonus;
if (effectiveMissCount > 0)
- aimValue *= calculateMissPenalty(effectiveMissCount);
+ aimValue *= calculateMissPenalty(effectiveMissCount, Attributes.AimDifficultStrainCount);
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
@@ -148,7 +148,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
speedValue *= lengthBonus;
if (effectiveMissCount > 0)
- speedValue *= calculateMissPenalty(effectiveMissCount);
+ speedValue *= calculateMissPenalty(effectiveMissCount, Attributes.SpeedDifficultStrainCount);
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
@@ -267,17 +267,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty
return Math.Max(countMiss, (int)Math.Floor(comboBasedMissCount));
}
- private double calculateMissPenalty(double missCount)
+ private double calculateMissPenalty(double missCount, double strainCount)
{
- double leniency = 4.3;
-
- if (missCount > totalHits - leniency)
- return 0;
-
- double missApprox = SpecialFunctions.ErfInv((totalHits - leniency - missCount) / totalHits);
- double fcApprox = SpecialFunctions.ErfInv((totalHits - leniency) / totalHits);
-
- return Math.Pow(missApprox / fcApprox, 3.5);
+ return 0.95 / ((missCount / (3 * Math.Sqrt(strainCount))) + 1);
}
private int totalHits => countGreat + countOk + countMeh + countMiss;
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index e47edc37cc..43e39482a7 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -57,5 +57,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
return difficulty * DifficultyMultiplier;
}
+
+ public int RelevantDifficultStrains()
+ {
+ List strains = GetCurrentStrainPeaks().OrderByDescending(d => d).ToList();
+
+ return strains.Count(s => s > strains[0] * 0.66);
+ }
}
}
From e9589e57a662bc47297fec2429d7bfce1256db68 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Mon, 27 Dec 2021 02:23:03 +0000
Subject: [PATCH 007/924] Fix logical error
---
osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
index ac228b0a32..87ab12248f 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
@@ -45,7 +45,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
// Total number of strains in a map can vary by clockrate, and this needs to be corrected for.
aimDifficultyStrainCount = (int)(aimDifficultyStrainCount * clockRate);
- speedDifficultyStrainCount = (int)(aimDifficultyStrainCount * clockRate);
+ speedDifficultyStrainCount = (int)(speedDifficultyStrainCount * clockRate);
if (mods.Any(h => h is OsuModRelax))
speedRating = 0.0;
From 8ce6e3c573104d55956c9a3c4cd3c8beffd41b09 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Wed, 29 Dec 2021 18:49:13 +0000
Subject: [PATCH 008/924] Remove mathnet
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 4 ----
osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj | 4 ----
2 files changed, 8 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index d7d294df47..f6e5481feb 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -99,8 +99,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (effectiveMissCount > 0)
aimValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), effectiveMissCount);
- aimValue *= getComboScalingFactor();
-
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
approachRateFactor = 0.3 * (Attributes.ApproachRate - 10.33);
@@ -146,8 +144,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (effectiveMissCount > 0)
speedValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
- speedValue *= getComboScalingFactor();
-
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
approachRateFactor = 0.3 * (Attributes.ApproachRate - 10.33);
diff --git a/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj b/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj
index 018bdb93df..98f1e69bd1 100644
--- a/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj
+++ b/osu.Game.Rulesets.Osu/osu.Game.Rulesets.Osu.csproj
@@ -15,8 +15,4 @@
-
-
-
-
\ No newline at end of file
From 4f257d6987b1144912f561d5a3360593598be834 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Wed, 29 Dec 2021 18:59:17 +0000
Subject: [PATCH 009/924] Clean up unsuccessful merge
---
.../Difficulty/OsuPerformanceCalculator.cs | 12 ++++++++----
1 file changed, 8 insertions(+), 4 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index f6e5481feb..793f9e790f 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -95,9 +95,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
(totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
aimValue *= lengthBonus;
- // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
if (effectiveMissCount > 0)
- aimValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), effectiveMissCount);
+ aimValue *= calculateMissPenalty(effectiveMissCount, Attributes.AimDifficultStrainCount);
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
@@ -140,9 +139,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
(totalHits > 2000 ? Math.Log10(totalHits / 2000.0) * 0.5 : 0.0);
speedValue *= lengthBonus;
- // Penalize misses by assessing # of misses relative to the total # of objects. Default a 3% reduction for any # of misses.
if (effectiveMissCount > 0)
- speedValue *= 0.97 * Math.Pow(1 - Math.Pow((double)effectiveMissCount / totalHits, 0.775), Math.Pow(effectiveMissCount, .875));
+ speedValue *= calculateMissPenalty(effectiveMissCount, Attributes.SpeedDifficultStrainCount);
double approachRateFactor = 0.0;
if (Attributes.ApproachRate > 10.33)
@@ -259,6 +257,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
}
private double getComboScalingFactor() => Attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
+
+ private double calculateMissPenalty(double missCount, double strainCount)
+ {
+ return 0.95 / ((missCount / (3 * Math.Sqrt(strainCount))) + 1);
+ }
+
private int totalHits => countGreat + countOk + countMeh + countMiss;
private int totalSuccessfulHits => countGreat + countOk + countMeh;
}
From fd1028f3bb5c0f19ac2154974fafa528ea6e52e9 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Wed, 29 Dec 2021 23:49:07 +0000
Subject: [PATCH 010/924] Use clockrate in the difficult strain count method
---
.../Difficulty/OsuDifficultyCalculator.cs | 8 ++------
.../Difficulty/Skills/OsuStrainSkill.cs | 9 +++++++--
2 files changed, 9 insertions(+), 8 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
index 44ba6c6a58..27d97e9d75 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
@@ -40,12 +40,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;
- int aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).RelevantDifficultStrains();
- int speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).RelevantDifficultStrains();
-
- // Total number of strains in a map can vary by clockrate, and this needs to be corrected for.
- aimDifficultyStrainCount = (int)(aimDifficultyStrainCount * clockRate);
- speedDifficultyStrainCount = (int)(speedDifficultyStrainCount * clockRate);
+ int aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).CountDifficultStrains(clockRate);
+ int speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).CountDifficultStrains(clockRate);
if (mods.Any(h => h is OsuModRelax))
speedRating = 0.0;
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index 43e39482a7..fd751727a9 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -58,11 +58,16 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
return difficulty * DifficultyMultiplier;
}
- public int RelevantDifficultStrains()
+ ///
+ /// Returns the number of difficult strains.
+ /// A strain is considered difficult if it's higher than 66% of the highest strain.
+ ///
+ public int CountDifficultStrains(double clockRate)
{
List strains = GetCurrentStrainPeaks().OrderByDescending(d => d).ToList();
- return strains.Count(s => s > strains[0] * 0.66);
+ // Total number of strains in a map can vary by clockrate, and this needs to be corrected for.
+ return (int)(strains.Count(s => s > strains[0] * 0.66) * clockRate);
}
}
}
From d2b815b745b1cfaef241488c436b26fede000571 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Sun, 2 Jan 2022 19:20:20 +0000
Subject: [PATCH 011/924] Add miss penalty comment
---
.../Difficulty/OsuPerformanceCalculator.cs | 9 +++------
1 file changed, 3 insertions(+), 6 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 793f9e790f..d8fe85d645 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -256,13 +256,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
return Math.Max(countMiss, (int)Math.Floor(comboBasedMissCount));
}
+ // Miss penalty assumes that a player will miss on the relatively hard parts of a map, not the easy parts, hence the strain count.
+ private double calculateMissPenalty(double missCount, double strainCount) => 0.95 / ((missCount / (3 * Math.Sqrt(strainCount))) + 1);
+
private double getComboScalingFactor() => Attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
-
- private double calculateMissPenalty(double missCount, double strainCount)
- {
- return 0.95 / ((missCount / (3 * Math.Sqrt(strainCount))) + 1);
- }
-
private int totalHits => countGreat + countOk + countMeh + countMiss;
private int totalSuccessfulHits => countGreat + countOk + countMeh;
}
From 75be4e83d6a44adc7016c150b5cbd1c74d1caf34 Mon Sep 17 00:00:00 2001
From: Luminiscental
Date: Mon, 3 Jan 2022 22:22:32 +0000
Subject: [PATCH 012/924] Remove abusable 0.66 threshold by averaging
---
.../Difficulty/Skills/OsuStrainSkill.cs | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index fd751727a9..1513befad5 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -59,15 +59,15 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
}
///
- /// Returns the number of difficult strains.
- /// A strain is considered difficult if it's higher than 66% of the highest strain.
+ /// Returns the number of strains above a threshold averaged as the threshold varies.
+ /// The result is scaled by clock rate as it affects the total number of strains.
///
public int CountDifficultStrains(double clockRate)
{
- List strains = GetCurrentStrainPeaks().OrderByDescending(d => d).ToList();
-
- // Total number of strains in a map can vary by clockrate, and this needs to be corrected for.
- return (int)(strains.Count(s => s > strains[0] * 0.66) * clockRate);
+ List strains = GetCurrentStrainPeaks().ToList();
+ // This is the average value of strains.Count(s => s > p * strains.Max()) for p between 0 and 1.
+ double realtimeCount = strains.Sum() / strains.Max();
+ return (int)(clockRate * realtimeCount);
}
}
}
From 132079004ca5e6df33a2bc646a52f3036edff85e Mon Sep 17 00:00:00 2001
From: Luminiscental
Date: Tue, 4 Jan 2022 12:30:05 +0000
Subject: [PATCH 013/924] Remove unnecessary truncation
---
osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs | 4 ++--
osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs | 4 ++--
osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs | 4 ++--
3 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
index 51842f65d5..7ab4232a19 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
@@ -25,10 +25,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
public double SliderFactor { get; set; }
[JsonProperty("aim_difficult_strain_count")]
- public int AimDifficultStrainCount { get; set; }
+ public double AimDifficultStrainCount { get; set; }
[JsonProperty("speed_difficult_strain_count")]
- public int SpeedDifficultStrainCount { get; set; }
+ public double SpeedDifficultStrainCount { get; set; }
[JsonProperty("approach_rate")]
public double ApproachRate { get; set; }
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
index 27d97e9d75..3c039c9b7e 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
@@ -40,8 +40,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;
- int aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).CountDifficultStrains(clockRate);
- int speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).CountDifficultStrains(clockRate);
+ double aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).CountDifficultStrains(clockRate);
+ double speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).CountDifficultStrains(clockRate);
if (mods.Any(h => h is OsuModRelax))
speedRating = 0.0;
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index 1513befad5..46dc9c683b 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -62,12 +62,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
/// Returns the number of strains above a threshold averaged as the threshold varies.
/// The result is scaled by clock rate as it affects the total number of strains.
///
- public int CountDifficultStrains(double clockRate)
+ public double CountDifficultStrains(double clockRate)
{
List strains = GetCurrentStrainPeaks().ToList();
// This is the average value of strains.Count(s => s > p * strains.Max()) for p between 0 and 1.
double realtimeCount = strains.Sum() / strains.Max();
- return (int)(clockRate * realtimeCount);
+ return clockRate * realtimeCount;
}
}
}
From 443640a48c8bed53510947240e8337c9350d8d6d Mon Sep 17 00:00:00 2001
From: apollo <83023433+apollo-dw@users.noreply.github.com>
Date: Tue, 4 Jan 2022 16:39:30 +0000
Subject: [PATCH 014/924] Revert "Remove abusable 0.66 threshold by averaging"
---
.../Difficulty/OsuDifficultyAttributes.cs | 4 ++--
.../Difficulty/OsuDifficultyCalculator.cs | 4 ++--
.../Difficulty/Skills/OsuStrainSkill.cs | 14 +++++++-------
3 files changed, 11 insertions(+), 11 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
index 7ab4232a19..51842f65d5 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
@@ -25,10 +25,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
public double SliderFactor { get; set; }
[JsonProperty("aim_difficult_strain_count")]
- public double AimDifficultStrainCount { get; set; }
+ public int AimDifficultStrainCount { get; set; }
[JsonProperty("speed_difficult_strain_count")]
- public double SpeedDifficultStrainCount { get; set; }
+ public int SpeedDifficultStrainCount { get; set; }
[JsonProperty("approach_rate")]
public double ApproachRate { get; set; }
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
index 3c039c9b7e..27d97e9d75 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
@@ -40,8 +40,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;
- double aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).CountDifficultStrains(clockRate);
- double speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).CountDifficultStrains(clockRate);
+ int aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).CountDifficultStrains(clockRate);
+ int speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).CountDifficultStrains(clockRate);
if (mods.Any(h => h is OsuModRelax))
speedRating = 0.0;
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index 46dc9c683b..fd751727a9 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -59,15 +59,15 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
}
///
- /// Returns the number of strains above a threshold averaged as the threshold varies.
- /// The result is scaled by clock rate as it affects the total number of strains.
+ /// Returns the number of difficult strains.
+ /// A strain is considered difficult if it's higher than 66% of the highest strain.
///
- public double CountDifficultStrains(double clockRate)
+ public int CountDifficultStrains(double clockRate)
{
- List strains = GetCurrentStrainPeaks().ToList();
- // This is the average value of strains.Count(s => s > p * strains.Max()) for p between 0 and 1.
- double realtimeCount = strains.Sum() / strains.Max();
- return clockRate * realtimeCount;
+ List strains = GetCurrentStrainPeaks().OrderByDescending(d => d).ToList();
+
+ // Total number of strains in a map can vary by clockrate, and this needs to be corrected for.
+ return (int)(strains.Count(s => s > strains[0] * 0.66) * clockRate);
}
}
}
From dcb969316dd5a7e2bd1b06ebd1450a0ab56ef831 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Tue, 4 Jan 2022 17:33:23 +0000
Subject: [PATCH 015/924] Weight difficult strain count against the top strain
---
osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs | 7 ++++---
1 file changed, 4 insertions(+), 3 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index 46dc9c683b..3e0fccb6c4 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -59,14 +59,15 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
}
///
- /// Returns the number of strains above a threshold averaged as the threshold varies.
+ /// Returns the number of strains weighted against the top strain.
/// The result is scaled by clock rate as it affects the total number of strains.
///
public double CountDifficultStrains(double clockRate)
{
List strains = GetCurrentStrainPeaks().ToList();
- // This is the average value of strains.Count(s => s > p * strains.Max()) for p between 0 and 1.
- double realtimeCount = strains.Sum() / strains.Max();
+ double topStrain = strains.Max();
+
+ double realtimeCount = strains.Sum(s => Math.Pow(s / topStrain, 4));
return clockRate * realtimeCount;
}
}
From 400abc147b1f3742061125d91e80a62f5e1333f7 Mon Sep 17 00:00:00 2001
From: Dan Balasescu
Date: Thu, 6 Jan 2022 16:28:04 +0900
Subject: [PATCH 016/924] Add attribute ids to mapping functions
---
osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs | 4 ++++
osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs | 2 ++
2 files changed, 6 insertions(+)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
index 7ab4232a19..7041acc16c 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyAttributes.cs
@@ -60,6 +60,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
yield return (ATTRIB_ID_FLASHLIGHT, FlashlightDifficulty);
yield return (ATTRIB_ID_SLIDER_FACTOR, SliderFactor);
+ yield return (ATTRIB_ID_AIM_DIFFICULT_STRAIN_COUNT, AimDifficultStrainCount);
+ yield return (ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT, SpeedDifficultStrainCount);
}
public override void FromDatabaseAttributes(IReadOnlyDictionary values)
@@ -74,6 +76,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
StarRating = values[ATTRIB_ID_DIFFICULTY];
FlashlightDifficulty = values.GetValueOrDefault(ATTRIB_ID_FLASHLIGHT);
SliderFactor = values[ATTRIB_ID_SLIDER_FACTOR];
+ AimDifficultStrainCount = values[ATTRIB_ID_AIM_DIFFICULT_STRAIN_COUNT];
+ SpeedDifficultStrainCount = values[ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT];
}
#region Newtonsoft.Json implicit ShouldSerialize() methods
diff --git a/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs b/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs
index 991b567f57..803a5bdac7 100644
--- a/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs
+++ b/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs
@@ -24,6 +24,8 @@ namespace osu.Game.Rulesets.Difficulty
protected const int ATTRIB_ID_SCORE_MULTIPLIER = 15;
protected const int ATTRIB_ID_FLASHLIGHT = 17;
protected const int ATTRIB_ID_SLIDER_FACTOR = 19;
+ protected const int ATTRIB_ID_AIM_DIFFICULT_STRAIN_COUNT = 21;
+ protected const int ATTRIB_ID_SPEED_DIFFICULT_STRAIN_COUNT = 23;
///
/// The mods which were applied to the beatmap.
From 598946737f07c0f2a3ac7523666a868722906db1 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Wed, 12 Jan 2022 14:38:53 +0000
Subject: [PATCH 017/924] Reword comment and rename argument
---
.../Difficulty/OsuPerformanceCalculator.cs | 7 ++++---
1 file changed, 4 insertions(+), 3 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index d8fe85d645..52658dfe38 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -256,9 +256,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
return Math.Max(countMiss, (int)Math.Floor(comboBasedMissCount));
}
- // Miss penalty assumes that a player will miss on the relatively hard parts of a map, not the easy parts, hence the strain count.
- private double calculateMissPenalty(double missCount, double strainCount) => 0.95 / ((missCount / (3 * Math.Sqrt(strainCount))) + 1);
-
+ // Miss penalty assumes that a player will miss on the hardest parts of a map,
+ // so we use the amount of relatively difficult sections to adjust miss penalty
+ // to make it more punishing on maps with lower amount of hard sections.
+ private double calculateMissPenalty(double missCount, double difficultStrainCount) => 0.95 / ((missCount / (3 * Math.Sqrt(difficultStrainCount))) + 1);
private double getComboScalingFactor() => Attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
private int totalHits => countGreat + countOk + countMeh + countMiss;
private int totalSuccessfulHits => countGreat + countOk + countMeh;
From da31ca17e7c12a2922ab83657df4d8d9b6826bbd Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Mon, 14 Feb 2022 01:53:03 +0000
Subject: [PATCH 018/924] Use note strains instead of sectional strains
---
osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs | 2 ++
osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs | 7 ++++---
osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs | 6 +++++-
3 files changed, 11 insertions(+), 4 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
index a6301aed6d..3486db04af 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
@@ -159,6 +159,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
currentStrain *= strainDecay(current.DeltaTime);
currentStrain += strainValueOf(current) * skillMultiplier;
+ objectStrains.Add(currentStrain);
+
return currentStrain;
}
}
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index 3e0fccb6c4..94e2c9d774 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -28,6 +28,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
///
protected virtual double DifficultyMultiplier => 1.06;
+ protected List objectStrains = new List();
+
protected OsuStrainSkill(Mod[] mods)
: base(mods)
{
@@ -64,10 +66,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
///
public double CountDifficultStrains(double clockRate)
{
- List strains = GetCurrentStrainPeaks().ToList();
- double topStrain = strains.Max();
+ double topStrain = objectStrains.Max();
- double realtimeCount = strains.Sum(s => Math.Pow(s / topStrain, 4));
+ double realtimeCount = objectStrains.Sum(s => Math.Pow(s / topStrain, 4));
return clockRate * realtimeCount;
}
}
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
index 06d1ef7346..108edc6f2d 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
@@ -173,7 +173,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
currentRhythm = calculateRhythmBonus(current);
- return currentStrain * currentRhythm;
+ double totalStrain = currentStrain * currentRhythm;
+
+ objectStrains.Add(totalStrain);
+
+ return totalStrain;
}
}
}
From 94a46ab640b36c3ca58f03eaf2644ab51c3abd51 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Mon, 14 Feb 2022 02:02:46 +0000
Subject: [PATCH 019/924] Rescale miss penalty for note strains
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index cf2116cc5d..cf1af18d39 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -259,7 +259,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
// Miss penalty assumes that a player will miss on the hardest parts of a map,
// so we use the amount of relatively difficult sections to adjust miss penalty
// to make it more punishing on maps with lower amount of hard sections.
- private double calculateMissPenalty(double missCount, double difficultStrainCount) => 0.95 / ((missCount / (3 * Math.Sqrt(difficultStrainCount))) + 1);
+ private double calculateMissPenalty(double missCount, double difficultStrainCount) => 0.94 / ((missCount / (2 * Math.Sqrt(difficultStrainCount))) + 1);
private double getComboScalingFactor() => Attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(Attributes.MaxCombo, 0.8), 1.0);
private int totalHits => countGreat + countOk + countMeh + countMiss;
private int totalSuccessfulHits => countGreat + countOk + countMeh;
From c18df86720244a7d5bba22bc502afd4f959c9082 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Sat, 19 Feb 2022 15:33:28 +0000
Subject: [PATCH 020/924] Remove clockrate factor
---
osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs | 4 ++--
osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs | 5 ++---
2 files changed, 4 insertions(+), 5 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
index 3c039c9b7e..788b515d7f 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
@@ -40,8 +40,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double sliderFactor = aimRating > 0 ? aimRatingNoSliders / aimRating : 1;
- double aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).CountDifficultStrains(clockRate);
- double speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).CountDifficultStrains(clockRate);
+ double aimDifficultyStrainCount = ((OsuStrainSkill)skills[0]).CountDifficultStrains();
+ double speedDifficultyStrainCount = ((OsuStrainSkill)skills[2]).CountDifficultStrains();
if (mods.Any(h => h is OsuModRelax))
speedRating = 0.0;
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index 94e2c9d774..1124c4466f 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -64,12 +64,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
/// Returns the number of strains weighted against the top strain.
/// The result is scaled by clock rate as it affects the total number of strains.
///
- public double CountDifficultStrains(double clockRate)
+ public double CountDifficultStrains()
{
double topStrain = objectStrains.Max();
- double realtimeCount = objectStrains.Sum(s => Math.Pow(s / topStrain, 4));
- return clockRate * realtimeCount;
+ return objectStrains.Sum(s => Math.Pow(s / topStrain, 4));
}
}
}
From 2f335a76dca77b0304f5ff21ed7ca2c8e1130757 Mon Sep 17 00:00:00 2001
From: apollo-dw <83023433+apollo-dw@users.noreply.github.com>
Date: Thu, 17 Mar 2022 22:08:56 +0000
Subject: [PATCH 021/924] Switch to using osuAttributes
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 48b4f53a3e..964bd73e81 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -92,7 +92,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
aimValue *= lengthBonus;
if (effectiveMissCount > 0)
- aimValue *= calculateMissPenalty(effectiveMissCount, Attributes.AimDifficultStrainCount);
+ aimValue *= calculateMissPenalty(effectiveMissCount, attributes.AimDifficultStrainCount);
double approachRateFactor = 0.0;
if (attributes.ApproachRate > 10.33)
@@ -136,7 +136,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
speedValue *= lengthBonus;
if (effectiveMissCount > 0)
- speedValue *= calculateMissPenalty(effectiveMissCount, Attributes.SpeedDifficultStrainCount);
+ speedValue *= calculateMissPenalty(effectiveMissCount, attributes.SpeedDifficultStrainCount);
double approachRateFactor = 0.0;
if (attributes.ApproachRate > 10.33)
From 442e68ac1a496529869e7cbb75ad40bc4881aef4 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Tue, 25 Oct 2022 17:41:20 -0400
Subject: [PATCH 022/924] Implement taiko deviation estimation
---
.../Difficulty/TaikoPerformanceAttributes.cs | 3 +++
.../Difficulty/TaikoPerformanceCalculator.cs | 27 +++++++++++++++----
.../osu.Game.Rulesets.Taiko.csproj | 4 +++
3 files changed, 29 insertions(+), 5 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
index b61c13a2df..fa8c3fd27a 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
@@ -19,6 +19,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
[JsonProperty("effective_miss_count")]
public double EffectiveMissCount { get; set; }
+
+ [JsonProperty("estimated_ur")]
+ public double EstimatedUR { get; set; }
public override IEnumerable GetAttributesForDisplay()
{
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index dc7bad2f75..7d5cf3accd 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -11,6 +11,7 @@ using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Scoring;
using osu.Game.Rulesets.Taiko.Objects;
using osu.Game.Scoring;
+using MathNet.Numerics;
namespace osu.Game.Rulesets.Taiko.Difficulty
{
@@ -21,6 +22,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
private int countMeh;
private int countMiss;
private double accuracy;
+ private double estimatedUR;
private double effectiveMissCount;
@@ -37,7 +39,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
- accuracy = customAccuracy;
+ estimatedUR = 10 * computeEstimatedUR(score, taikoAttributes);
// The effectiveMissCount is calculated by gaining a ratio for totalSuccessfulHits and increasing the miss penalty for shorter object counts lower than 1000.
if (totalSuccessfulHits > 0)
@@ -64,6 +66,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
Difficulty = difficultyValue,
Accuracy = accuracyValue,
EffectiveMissCount = effectiveMissCount,
+ EstimatedUR = 10 * estimatedUR,
Total = totalValue
};
}
@@ -97,10 +100,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (attributes.GreatHitWindow <= 0)
return 0;
- double accuracyValue = Math.Pow(60.0 / attributes.GreatHitWindow, 1.1) * Math.Pow(accuracy, 8.0) * Math.Pow(attributes.StarRating, 0.4) * 27.0;
+ double accuracyValue = Math.Pow(75 / estimatedUR, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 70.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
- accuracyValue *= lengthBonus;
// Slight HDFL Bonus for accuracy. A clamp is used to prevent against negative values
if (score.Mods.Any(m => m is ModFlashlight) && score.Mods.Any(m => m is ModHidden))
@@ -109,10 +111,25 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
return accuracyValue;
}
+ private double computeEstimatedUR(ScoreInfo score, TaikoDifficultyAttributes attributes)
+ {
+ if (totalHits == 0)
+ return double.PositiveInfinity;
+
+ double greatProbability = 1 - (countOk + countMiss + 1.0) / (totalHits + 1.0);
+
+ if (greatProbability <= 0)
+ {
+ return double.PositiveInfinity;
+ }
+
+ double deviation = attributes.GreatHitWindow / (Math.Sqrt(2) * SpecialFunctions.ErfInv(greatProbability));
+
+ return deviation;
+ }
+
private int totalHits => countGreat + countOk + countMeh + countMiss;
private int totalSuccessfulHits => countGreat + countOk + countMeh;
-
- private double customAccuracy => totalHits > 0 ? (countGreat * 300 + countOk * 150) / (totalHits * 300.0) : 0;
}
}
diff --git a/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj b/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj
index b752c13d18..b2953106d8 100644
--- a/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj
+++ b/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj
@@ -15,4 +15,8 @@
+
+
+
+
From d5b06ae9454885e3eeec8de652a8cd51c86d8b7a Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Tue, 25 Oct 2022 17:52:34 -0400
Subject: [PATCH 023/924] Fix difficultyvalue acc scaling
---
.../Difficulty/TaikoPerformanceCalculator.cs | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 7d5cf3accd..ee2105d859 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -21,7 +21,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
private int countOk;
private int countMeh;
private int countMiss;
- private double accuracy;
private double estimatedUR;
private double effectiveMissCount;
@@ -92,7 +91,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (score.Mods.Any(m => m is ModFlashlight))
difficultyValue *= 1.050 * lengthBonus;
- return difficultyValue * Math.Pow(accuracy, 2.0);
+ return difficultyValue * Math.Pow(100 * SpecialFunctions.Erf(400 / (Math.Sqrt(2) * estimatedUR)), 2.0);
}
private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes)
From 607a006c4f5b11be1f4e8c223c8cfea2b96a9c19 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Tue, 25 Oct 2022 17:55:16 -0400
Subject: [PATCH 024/924] oops
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index ee2105d859..ba96e0b95e 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -91,7 +91,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (score.Mods.Any(m => m is ModFlashlight))
difficultyValue *= 1.050 * lengthBonus;
- return difficultyValue * Math.Pow(100 * SpecialFunctions.Erf(400 / (Math.Sqrt(2) * estimatedUR)), 2.0);
+ return difficultyValue * Math.Pow(SpecialFunctions.Erf(400 / (Math.Sqrt(2) * estimatedUR)), 2.0);
}
private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes)
From 87cba2d828455b88c26e6eb813667c916ec07c60 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Tue, 25 Oct 2022 19:15:58 -0400
Subject: [PATCH 025/924] Slight adjustments
---
.../Difficulty/TaikoPerformanceCalculator.cs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index ba96e0b95e..ec5c150ea4 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
Difficulty = difficultyValue,
Accuracy = accuracyValue,
EffectiveMissCount = effectiveMissCount,
- EstimatedUR = 10 * estimatedUR,
+ EstimatedUR = estimatedUR,
Total = totalValue
};
}
@@ -99,7 +99,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (attributes.GreatHitWindow <= 0)
return 0;
- double accuracyValue = Math.Pow(75 / estimatedUR, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 70.0;
+ double accuracyValue = Math.Pow(75 / estimatedUR, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
From 7d3338a0eacb1d4ecbcdb82ee98f8f34d2ac4a3d Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Wed, 26 Oct 2022 15:58:20 -0400
Subject: [PATCH 026/924] LTCA Balancing pass
---
.../Difficulty/TaikoPerformanceCalculator.cs | 16 ++++++++--------
1 file changed, 8 insertions(+), 8 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index ec5c150ea4..2a7cb6c6b5 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
private int countOk;
private int countMeh;
private int countMiss;
- private double estimatedUR;
+ private double estimatedDeviation;
private double effectiveMissCount;
@@ -38,7 +38,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
- estimatedUR = 10 * computeEstimatedUR(score, taikoAttributes);
+ estimatedDeviation = computeEstimatedDeviation(score, taikoAttributes);
// The effectiveMissCount is calculated by gaining a ratio for totalSuccessfulHits and increasing the miss penalty for shorter object counts lower than 1000.
if (totalSuccessfulHits > 0)
@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
Difficulty = difficultyValue,
Accuracy = accuracyValue,
EffectiveMissCount = effectiveMissCount,
- EstimatedUR = estimatedUR,
+ EstimatedUR = estimatedDeviation * 10,
Total = totalValue
};
}
@@ -86,12 +86,12 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
difficultyValue *= 1.025;
if (score.Mods.Any(m => m is ModHardRock))
- difficultyValue *= 1.050;
+ difficultyValue *= 1.10;
if (score.Mods.Any(m => m is ModFlashlight))
difficultyValue *= 1.050 * lengthBonus;
- return difficultyValue * Math.Pow(SpecialFunctions.Erf(400 / (Math.Sqrt(2) * estimatedUR)), 2.0);
+ return difficultyValue * Math.Pow(SpecialFunctions.Erf(400 / (Math.Sqrt(2) * estimatedDeviation)), 2.0);
}
private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes)
@@ -99,18 +99,18 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (attributes.GreatHitWindow <= 0)
return 0;
- double accuracyValue = Math.Pow(75 / estimatedUR, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
+ double accuracyValue = Math.Pow(7.5 / estimatedDeviation, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
// Slight HDFL Bonus for accuracy. A clamp is used to prevent against negative values
if (score.Mods.Any(m => m is ModFlashlight) && score.Mods.Any(m => m is ModHidden))
- accuracyValue *= Math.Max(1.050, 1.075 * lengthBonus);
+ accuracyValue *= Math.Max(1.0, 1.05 * lengthBonus);
return accuracyValue;
}
- private double computeEstimatedUR(ScoreInfo score, TaikoDifficultyAttributes attributes)
+ private double computeEstimatedDeviation(ScoreInfo score, TaikoDifficultyAttributes attributes)
{
if (totalHits == 0)
return double.PositiveInfinity;
From af919a6550f58da73784931883e59e4b042f910b Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Wed, 26 Oct 2022 16:10:36 -0400
Subject: [PATCH 027/924] harshen deviation scaling
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 2a7cb6c6b5..565d166c32 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -91,7 +91,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (score.Mods.Any(m => m is ModFlashlight))
difficultyValue *= 1.050 * lengthBonus;
- return difficultyValue * Math.Pow(SpecialFunctions.Erf(400 / (Math.Sqrt(2) * estimatedDeviation)), 2.0);
+ return difficultyValue * Math.Pow(SpecialFunctions.Erf(40 / (Math.Sqrt(2) * estimatedDeviation)), 2.0);
}
private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes)
From 2940d18d3393c1e006c715ec47d5d2fa88b1bf61 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Thu, 27 Oct 2022 00:07:32 -0400
Subject: [PATCH 028/924] Fix formatting
---
.../Difficulty/TaikoPerformanceAttributes.cs | 2 +-
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
index fa8c3fd27a..6893f24d20 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
[JsonProperty("effective_miss_count")]
public double EffectiveMissCount { get; set; }
-
+
[JsonProperty("estimated_ur")]
public double EstimatedUR { get; set; }
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 565d166c32..1e57d77d91 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -114,7 +114,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
{
if (totalHits == 0)
return double.PositiveInfinity;
-
+
double greatProbability = 1 - (countOk + countMiss + 1.0) / (totalHits + 1.0);
if (greatProbability <= 0)
From 883790c7a78a7a69b08a3d5299557d2e245c16f5 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Fri, 28 Oct 2022 16:18:17 -0400
Subject: [PATCH 029/924] Return null instead of infinity
---
.../Difficulty/TaikoPerformanceAttributes.cs | 2 +-
.../Difficulty/TaikoPerformanceCalculator.cs | 15 +++++++++------
2 files changed, 10 insertions(+), 7 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
index 6893f24d20..3786009a1f 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
public double EffectiveMissCount { get; set; }
[JsonProperty("estimated_ur")]
- public double EstimatedUR { get; set; }
+ public double? EstimatedUR { get; set; }
public override IEnumerable GetAttributesForDisplay()
{
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 1e57d77d91..c27efb518d 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
private int countOk;
private int countMeh;
private int countMiss;
- private double estimatedDeviation;
+ private double? estimatedDeviation;
private double effectiveMissCount;
@@ -91,15 +91,18 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (score.Mods.Any(m => m is ModFlashlight))
difficultyValue *= 1.050 * lengthBonus;
- return difficultyValue * Math.Pow(SpecialFunctions.Erf(40 / (Math.Sqrt(2) * estimatedDeviation)), 2.0);
+ if (estimatedDeviation == null)
+ return 0;
+
+ return difficultyValue * Math.Pow(SpecialFunctions.Erf(40 / (Math.Sqrt(2) * (double)estimatedDeviation)), 2.0);
}
private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes)
{
- if (attributes.GreatHitWindow <= 0)
+ if (attributes.GreatHitWindow <= 0 || estimatedDeviation == null)
return 0;
- double accuracyValue = Math.Pow(7.5 / estimatedDeviation, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
+ double accuracyValue = Math.Pow(7.5 / (double)estimatedDeviation, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
@@ -110,10 +113,10 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
return accuracyValue;
}
- private double computeEstimatedDeviation(ScoreInfo score, TaikoDifficultyAttributes attributes)
+ private double? computeEstimatedDeviation(ScoreInfo score, TaikoDifficultyAttributes attributes)
{
if (totalHits == 0)
- return double.PositiveInfinity;
+ return null;
double greatProbability = 1 - (countOk + countMiss + 1.0) / (totalHits + 1.0);
From 01c79d8ef29abf4871335db06326eeef56d3fed6 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Fri, 28 Oct 2022 16:20:21 -0400
Subject: [PATCH 030/924] remove other infinity reference
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index c27efb518d..4fba926205 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -122,7 +122,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (greatProbability <= 0)
{
- return double.PositiveInfinity;
+ return null;
}
double deviation = attributes.GreatHitWindow / (Math.Sqrt(2) * SpecialFunctions.ErfInv(greatProbability));
From 7403c1cc862f6ebbd9e6a2bc791857b53a973da6 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Fri, 28 Oct 2022 23:23:50 -0400
Subject: [PATCH 031/924] Return null for greatprobability >= 1
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 4fba926205..003e46d77b 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -120,7 +120,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
double greatProbability = 1 - (countOk + countMiss + 1.0) / (totalHits + 1.0);
- if (greatProbability <= 0)
+ if (greatProbability <= 0 || greatProbability >= 1)
{
return null;
}
From 16301f052e8d64164e6f480a594e28868f940614 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Sun, 30 Oct 2022 15:01:25 -0400
Subject: [PATCH 032/924] Fix low end accuracy, buff high end
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 003e46d77b..c57efd3c4d 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -102,7 +102,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (attributes.GreatHitWindow <= 0 || estimatedDeviation == null)
return 0;
- double accuracyValue = Math.Pow(7.5 / (double)estimatedDeviation, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
+ double accuracyValue = Math.Pow(7.5 / (double)estimatedDeviation, 1.1) * Math.Pow(attributes.StarRating / 2.7, 0.8) * 100.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
From 37c21cdd7cbe4e00ae564dfce66d7a55ab1aa68e Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Tue, 1 Nov 2022 15:14:55 -0400
Subject: [PATCH 033/924] fix formatting
---
.../Difficulty/TaikoPerformanceAttributes.cs | 2 +-
.../Difficulty/TaikoPerformanceCalculator.cs | 8 ++++----
2 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
index 3786009a1f..74770eaa79 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
public double EffectiveMissCount { get; set; }
[JsonProperty("estimated_ur")]
- public double? EstimatedUR { get; set; }
+ public double? EstimatedUr { get; set; }
public override IEnumerable GetAttributesForDisplay()
{
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index c57efd3c4d..0a24e33419 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -65,7 +65,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
Difficulty = difficultyValue,
Accuracy = accuracyValue,
EffectiveMissCount = effectiveMissCount,
- EstimatedUR = estimatedDeviation * 10,
+ EstimatedUr = estimatedDeviation * 10,
Total = totalValue
};
}
@@ -94,7 +94,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (estimatedDeviation == null)
return 0;
- return difficultyValue * Math.Pow(SpecialFunctions.Erf(40 / (Math.Sqrt(2) * (double)estimatedDeviation)), 2.0);
+ return difficultyValue * Math.Pow(SpecialFunctions.Erf(40 / (Math.Sqrt(2) * estimatedDeviation.Value)), 2.0);
}
private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes)
@@ -102,7 +102,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (attributes.GreatHitWindow <= 0 || estimatedDeviation == null)
return 0;
- double accuracyValue = Math.Pow(7.5 / (double)estimatedDeviation, 1.1) * Math.Pow(attributes.StarRating / 2.7, 0.8) * 100.0;
+ double accuracyValue = Math.Pow(7.5 / estimatedDeviation.Value, 1.1) * Math.Pow(attributes.StarRating / 2.7, 0.8) * 100.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
@@ -120,7 +120,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
double greatProbability = 1 - (countOk + countMiss + 1.0) / (totalHits + 1.0);
- if (greatProbability <= 0 || greatProbability >= 1)
+ if (greatProbability is <= 0 or >= 1)
{
return null;
}
From 2ba163440aae865d656cf954bed3157d39b60d7f Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Thu, 24 Nov 2022 19:09:30 -0500
Subject: [PATCH 034/924] account for low acc FC deviation
---
.../Difficulty/TaikoPerformanceCalculator.cs | 51 ++++++++++++++++---
1 file changed, 45 insertions(+), 6 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 0a24e33419..281dc19837 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -12,6 +12,9 @@ using osu.Game.Rulesets.Scoring;
using osu.Game.Rulesets.Taiko.Objects;
using osu.Game.Scoring;
using MathNet.Numerics;
+using MathNet.Numerics.RootFinding;
+using osu.Framework.Audio.Track;
+using osu.Framework.Extensions.IEnumerableExtensions;
namespace osu.Game.Rulesets.Taiko.Difficulty
{
@@ -66,7 +69,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
Accuracy = accuracyValue,
EffectiveMissCount = effectiveMissCount,
EstimatedUr = estimatedDeviation * 10,
- Total = totalValue
+ Total = (double)estimatedDeviation * 10
};
}
@@ -118,20 +121,56 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (totalHits == 0)
return null;
- double greatProbability = 1 - (countOk + countMiss + 1.0) / (totalHits + 1.0);
+ // Create a new track to properly calculate the hit windows of 100s and 50s.
+ var track = new TrackVirtual(10000);
+ score.Mods.OfType().ForEach(m => m.ApplyToTrack(track));
+ double clockRate = track.Rate;
+ double overallDifficulty = (50 - attributes.GreatHitWindow) / 3 * clockRate;
+ double goodHitWindow = 0;
+ if (overallDifficulty <= 5)
+ goodHitWindow = (120 - 8 * overallDifficulty) / clockRate;
+ if (overallDifficulty > 5)
+ goodHitWindow = 80 - 6 * (overallDifficulty - 5);
+
+ double root2 = Math.Sqrt(2);
- if (greatProbability is <= 0 or >= 1)
+ double logLikelihoodGradient(double d)
{
- return null;
+ if (d <= 0)
+ return 1;
+
+ double p300 = SpecialFunctions.Erf(attributes.GreatHitWindow / root2 * d);
+ double lnP300 = lnErfcApprox(attributes.GreatHitWindow / root2 * d);
+ double lnP100 = lnErfcApprox(goodHitWindow / root2 * d);
+
+ double t1 = countGreat * ((attributes.GreatHitWindow * Math.Exp(-Math.Pow(attributes.GreatHitWindow / root2 * d, 2))) / p300);
+
+ double t2a = Math.Exp(Math.Log(goodHitWindow * Math.Exp(-Math.Pow(goodHitWindow / root2 * d, 2))) - logDiff(lnP300, lnP100));
+ double t2b = Math.Exp(Math.Log(attributes.GreatHitWindow * Math.Exp(-Math.Pow(attributes.GreatHitWindow / root2 * d, 2))) - logDiff(lnP300, lnP100));
+ double t2 = (countOk + 1) * (t2a - t2b);
+
+ double t3 = countMiss * Math.Exp(Math.Log(goodHitWindow * Math.Exp(-Math.Pow(goodHitWindow / root2 * d, 2))) - lnP100);
+
+ return t1 + t2 - t3;
}
- double deviation = attributes.GreatHitWindow / (Math.Sqrt(2) * SpecialFunctions.ErfInv(greatProbability));
+ double root = Brent.FindRootExpand(logLikelihoodGradient, 0.02, 0.3, expandFactor: 2);
- return deviation;
+ return 1 / root;
}
private int totalHits => countGreat + countOk + countMeh + countMiss;
private int totalSuccessfulHits => countGreat + countOk + countMeh;
+
+ double lnErfcApprox(double x)
+ {
+ if (x <= 5)
+ return Math.Log(SpecialFunctions.Erfc(x));
+
+ return -Math.Pow(x, 2) - Math.Log(x) - Math.Log(Math.Sqrt(Math.PI));
+ }
+
+ double logDiff(double l1, double l2) => l1 + SpecialFunctions.Log1p(-Math.Exp(-(l1 - l2)));
}
}
From 0e4e92b344b6bce55ccf6ceb776cc8bfb450338f Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Thu, 24 Nov 2022 19:28:47 -0500
Subject: [PATCH 035/924] totalvalue
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 281dc19837..332f6f8267 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -69,7 +69,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
Accuracy = accuracyValue,
EffectiveMissCount = effectiveMissCount,
EstimatedUr = estimatedDeviation * 10,
- Total = (double)estimatedDeviation * 10
+ Total = totalValue
};
}
From b579af674e128b94294ef9d379bc9a89d4dc94df Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Thu, 24 Nov 2022 19:46:55 -0500
Subject: [PATCH 036/924] fix dt
---
.../Difficulty/TaikoPerformanceCalculator.cs | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 332f6f8267..f184a7cdce 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -125,7 +125,8 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
var track = new TrackVirtual(10000);
score.Mods.OfType().ForEach(m => m.ApplyToTrack(track));
double clockRate = track.Rate;
- double overallDifficulty = (50 - attributes.GreatHitWindow) / 3 * clockRate;
+
+ double overallDifficulty = (50 - attributes.GreatHitWindow * clockRate) / 3;
double goodHitWindow = 0;
if (overallDifficulty <= 5)
goodHitWindow = (120 - 8 * overallDifficulty) / clockRate;
From e3ef180c4669b3197c7a527daaad76435fa2fa7f Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Fri, 25 Nov 2022 15:18:39 -0500
Subject: [PATCH 037/924] fixes
---
.../Difficulty/TaikoPerformanceCalculator.cs | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index f184a7cdce..d1e305fe9b 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -118,7 +118,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
private double? computeEstimatedDeviation(ScoreInfo score, TaikoDifficultyAttributes attributes)
{
- if (totalHits == 0)
+ if (totalSuccessfulHits == 0)
return null;
// Create a new track to properly calculate the hit windows of 100s and 50s.
@@ -155,7 +155,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
return t1 + t2 - t3;
}
- double root = Brent.FindRootExpand(logLikelihoodGradient, 0.02, 0.3, expandFactor: 2);
+ double root = Brent.FindRootExpand(logLikelihoodGradient, 0.02, 0.3);
return 1 / root;
}
@@ -164,7 +164,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
private int totalSuccessfulHits => countGreat + countOk + countMeh;
- double lnErfcApprox(double x)
+ private double lnErfcApprox(double x)
{
if (x <= 5)
return Math.Log(SpecialFunctions.Erfc(x));
@@ -172,6 +172,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
return -Math.Pow(x, 2) - Math.Log(x) - Math.Log(Math.Sqrt(Math.PI));
}
- double logDiff(double l1, double l2) => l1 + SpecialFunctions.Log1p(-Math.Exp(-(l1 - l2)));
+ private double logDiff(double l1, double l2) => l1 + SpecialFunctions.Log1p(-Math.Exp(-(l1 - l2)));
}
}
From 7b5373ac5a8f70c332840a5b1fe374f96ac51c19 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Sun, 27 Nov 2022 15:24:54 -0500
Subject: [PATCH 038/924] add comments
---
.../Difficulty/TaikoPerformanceCalculator.cs | 8 +++++++-
1 file changed, 7 insertions(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index d1e305fe9b..1d7af4e167 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -116,12 +116,17 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
return accuracyValue;
}
+ ///
+ /// Estimates the player's tap deviation based on the OD, number of objects, and number of 300s, 100s, and misses,
+ /// assuming the player's mean hit error is 0. The estimation is consistent in that two SS scores on the same map with the same settings
+ /// will always return the same deviation. See: https://www.desmos.com/calculator/qlr946netu
+ ///
private double? computeEstimatedDeviation(ScoreInfo score, TaikoDifficultyAttributes attributes)
{
if (totalSuccessfulHits == 0)
return null;
- // Create a new track to properly calculate the hit windows of 100s and 50s.
+ // Create a new track to properly calculate the hit window of 100s.
var track = new TrackVirtual(10000);
score.Mods.OfType().ForEach(m => m.ApplyToTrack(track));
double clockRate = track.Rate;
@@ -135,6 +140,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
double root2 = Math.Sqrt(2);
+ // Log of the most likely deviation resulting in the score's hit judgements, differentiated such that 1 over the most likely deviation returns 0.
double logLikelihoodGradient(double d)
{
if (d <= 0)
From 6a27206abdffa6e18bca1c3f27df6614b9abf869 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Fri, 2 Dec 2022 17:01:15 -0500
Subject: [PATCH 039/924] bugfix + tests
---
.../Difficulty/TaikoPerformanceCalculator.cs | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 19b43d0422..ca4e5fe53a 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -135,11 +135,11 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
double clockRate = track.Rate;
double overallDifficulty = (50 - attributes.GreatHitWindow * clockRate) / 3;
- double goodHitWindow = 0;
+ double goodHitWindow;
if (overallDifficulty <= 5)
goodHitWindow = (120 - 8 * overallDifficulty) / clockRate;
- if (overallDifficulty > 5)
- goodHitWindow = 80 - 6 * (overallDifficulty - 5);
+ else
+ goodHitWindow = (80 - 6 * (overallDifficulty - 5)) / clockRate;
double root2 = Math.Sqrt(2);
@@ -155,9 +155,9 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
double t1 = countGreat * ((attributes.GreatHitWindow * Math.Exp(-Math.Pow(attributes.GreatHitWindow / root2 * d, 2))) / p300);
- double t2a = Math.Exp(Math.Log(goodHitWindow * Math.Exp(-Math.Pow(goodHitWindow / root2 * d, 2))) - logDiff(lnP300, lnP100));
- double t2b = Math.Exp(Math.Log(attributes.GreatHitWindow * Math.Exp(-Math.Pow(attributes.GreatHitWindow / root2 * d, 2))) - logDiff(lnP300, lnP100));
- double t2 = (countOk + 1) * (t2a - t2b);
+ double t2A = Math.Exp(Math.Log(goodHitWindow * Math.Exp(-Math.Pow(goodHitWindow / root2 * d, 2))) - logDiff(lnP300, lnP100));
+ double t2B = Math.Exp(Math.Log(attributes.GreatHitWindow * Math.Exp(-Math.Pow(attributes.GreatHitWindow / root2 * d, 2))) - logDiff(lnP300, lnP100));
+ double t2 = (countOk + 1) * (t2A - t2B);
double t3 = countMiss * Math.Exp(Math.Log(goodHitWindow * Math.Exp(-Math.Pow(goodHitWindow / root2 * d, 2))) - lnP100);
From 2b74c4ef8cd60e9d3d6f7907962759573a8896d8 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Sat, 3 Dec 2022 15:39:38 -0500
Subject: [PATCH 040/924] tests return a greathitwindow of 0, add check
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index ca4e5fe53a..fd2dd47d30 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -126,7 +126,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
///
private double? computeEstimatedDeviation(ScoreInfo score, TaikoDifficultyAttributes attributes)
{
- if (totalSuccessfulHits == 0)
+ if (totalSuccessfulHits == 0 || attributes.GreatHitWindow == 0)
return null;
// Create a new track to properly calculate the hit window of 100s.
From 45e8d18b1b9618d8c068731a389285dc270dd2b4 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Mon, 5 Dec 2022 22:33:13 -0500
Subject: [PATCH 041/924] fix extremely low OD breaking deviation calc
---
.../Difficulty/TaikoPerformanceCalculator.cs | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index fd2dd47d30..807e9359fc 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -153,13 +153,13 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
double lnP300 = lnErfcApprox(attributes.GreatHitWindow / root2 * d);
double lnP100 = lnErfcApprox(goodHitWindow / root2 * d);
- double t1 = countGreat * ((attributes.GreatHitWindow * Math.Exp(-Math.Pow(attributes.GreatHitWindow / root2 * d, 2))) / p300);
+ double t1 = countGreat * (Math.Exp(Math.Log(attributes.GreatHitWindow) + -Math.Pow(attributes.GreatHitWindow / root2 * d, 2)) / p300);
- double t2A = Math.Exp(Math.Log(goodHitWindow * Math.Exp(-Math.Pow(goodHitWindow / root2 * d, 2))) - logDiff(lnP300, lnP100));
- double t2B = Math.Exp(Math.Log(attributes.GreatHitWindow * Math.Exp(-Math.Pow(attributes.GreatHitWindow / root2 * d, 2))) - logDiff(lnP300, lnP100));
+ double t2A = Math.Exp(Math.Log(goodHitWindow) + -Math.Pow(goodHitWindow / root2 * d, 2) - logDiff(lnP300, lnP100));
+ double t2B = Math.Exp(Math.Log(attributes.GreatHitWindow) + -Math.Pow(attributes.GreatHitWindow / root2 * d, 2) - logDiff(lnP300, lnP100));
double t2 = (countOk + 1) * (t2A - t2B);
- double t3 = countMiss * Math.Exp(Math.Log(goodHitWindow * Math.Exp(-Math.Pow(goodHitWindow / root2 * d, 2))) - lnP100);
+ double t3 = countMiss * Math.Exp(Math.Log(goodHitWindow) + -Math.Pow(goodHitWindow / root2 * d, 2) - lnP100);
return t1 + t2 - t3;
}
From 334f60f528b130cb47634e960c8fe47ff01581cc Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Wed, 22 Feb 2023 14:55:48 -0500
Subject: [PATCH 042/924] Reformat everything to be simpler
---
.../Difficulty/TaikoPerformanceCalculator.cs | 78 ++++++++++---------
1 file changed, 40 insertions(+), 38 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 807e9359fc..84b71a98d4 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -12,7 +12,6 @@ using osu.Game.Rulesets.Scoring;
using osu.Game.Rulesets.Taiko.Objects;
using osu.Game.Scoring;
using MathNet.Numerics;
-using MathNet.Numerics.RootFinding;
using osu.Framework.Audio.Track;
using osu.Framework.Extensions.IEnumerableExtensions;
@@ -24,7 +23,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
private int countOk;
private int countMeh;
private int countMiss;
- private double? estimatedDeviation;
+ private double? estimatedUr;
private double effectiveMissCount;
@@ -41,7 +40,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
- estimatedDeviation = computeEstimatedDeviation(score, taikoAttributes);
+ estimatedUr = computeEstimatedUr(score, taikoAttributes);
// The effectiveMissCount is calculated by gaining a ratio for totalSuccessfulHits and increasing the miss penalty for shorter object counts lower than 1000.
if (totalSuccessfulHits > 0)
@@ -71,7 +70,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
Difficulty = difficultyValue,
Accuracy = accuracyValue,
EffectiveMissCount = effectiveMissCount,
- EstimatedUr = estimatedDeviation * 10,
+ EstimatedUr = estimatedUr,
Total = totalValue
};
}
@@ -97,18 +96,18 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (score.Mods.Any(m => m is ModFlashlight))
difficultyValue *= 1.050 * lengthBonus;
- if (estimatedDeviation == null)
+ if (estimatedUr == null)
return 0;
- return difficultyValue * Math.Pow(SpecialFunctions.Erf(40 / (Math.Sqrt(2) * estimatedDeviation.Value)), 2.0);
+ return difficultyValue * Math.Pow(SpecialFunctions.Erf(400 / (Math.Sqrt(2) * estimatedUr.Value)), 2.0);
}
private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes, bool isConvert)
{
- if (attributes.GreatHitWindow <= 0 || estimatedDeviation == null)
+ if (attributes.GreatHitWindow <= 0 || estimatedUr == null)
return 0;
- double accuracyValue = Math.Pow(7.5 / estimatedDeviation.Value, 1.1) * Math.Pow(attributes.StarRating / 2.7, 0.8) * 100.0;
+ double accuracyValue = Math.Pow(75 / estimatedUr.Value, 1.1) * Math.Pow(attributes.StarRating / 2.7, 0.8) * 100.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
@@ -124,7 +123,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
/// assuming the player's mean hit error is 0. The estimation is consistent in that two SS scores on the same map with the same settings
/// will always return the same deviation. See: https://www.desmos.com/calculator/qlr946netu
///
- private double? computeEstimatedDeviation(ScoreInfo score, TaikoDifficultyAttributes attributes)
+ private double? computeEstimatedUr(ScoreInfo score, TaikoDifficultyAttributes attributes)
{
if (totalSuccessfulHits == 0 || attributes.GreatHitWindow == 0)
return null;
@@ -135,52 +134,55 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
double clockRate = track.Rate;
double overallDifficulty = (50 - attributes.GreatHitWindow * clockRate) / 3;
- double goodHitWindow;
- if (overallDifficulty <= 5)
- goodHitWindow = (120 - 8 * overallDifficulty) / clockRate;
- else
- goodHitWindow = (80 - 6 * (overallDifficulty - 5)) / clockRate;
+ double h300 = attributes.GreatHitWindow;
+ double h100 = overallDifficulty <= 5 ? (120 - 8 * overallDifficulty) / clockRate : (80 - 6 * (overallDifficulty - 5)) / clockRate;
- double root2 = Math.Sqrt(2);
-
- // Log of the most likely deviation resulting in the score's hit judgements, differentiated such that 1 over the most likely deviation returns 0.
- double logLikelihoodGradient(double d)
+ // Returns the likelihood of a deviation resulting in the score's hit judgements. The peak of the curve is the most likely deviation.
+ double likelihoodGradient(double d)
{
if (d <= 0)
- return 1;
+ return 0;
- double p300 = SpecialFunctions.Erf(attributes.GreatHitWindow / root2 * d);
- double lnP300 = lnErfcApprox(attributes.GreatHitWindow / root2 * d);
- double lnP100 = lnErfcApprox(goodHitWindow / root2 * d);
+ double p300 = logDiff(0, logPcHit(h300, d));
+ double p100 = logDiff(logPcHit(h300, d), logPcHit(h100, d));
+ double p0 = logPcHit(h100, d);
- double t1 = countGreat * (Math.Exp(Math.Log(attributes.GreatHitWindow) + -Math.Pow(attributes.GreatHitWindow / root2 * d, 2)) / p300);
+ double gradient = Math.Exp(
+ (countGreat * p300
+ + (countOk + 0.5) * p100
+ + countMiss * p0) / totalHits
+ );
- double t2A = Math.Exp(Math.Log(goodHitWindow) + -Math.Pow(goodHitWindow / root2 * d, 2) - logDiff(lnP300, lnP100));
- double t2B = Math.Exp(Math.Log(attributes.GreatHitWindow) + -Math.Pow(attributes.GreatHitWindow / root2 * d, 2) - logDiff(lnP300, lnP100));
- double t2 = (countOk + 1) * (t2A - t2B);
-
- double t3 = countMiss * Math.Exp(Math.Log(goodHitWindow) + -Math.Pow(goodHitWindow / root2 * d, 2) - lnP100);
-
- return t1 + t2 - t3;
+ return -gradient;
}
- double root = Brent.FindRootExpand(logLikelihoodGradient, 0.02, 0.3);
+ double deviation = FindMinimum.OfScalarFunction(likelihoodGradient, 30);
- return 1 / root;
+ return deviation * 10;
}
private int totalHits => countGreat + countOk + countMeh + countMiss;
private int totalSuccessfulHits => countGreat + countOk + countMeh;
- private double lnErfcApprox(double x)
+ private double logPcHit(double x, double deviation) => logErfcApprox(x / (deviation * Math.Sqrt(2)));
+
+ // There is a numerical approximation to increase how far you can calculate Erfc(x).
+ private double logErfcApprox(double x) => x <= 5 ? Math.Log(SpecialFunctions.Erfc(x)) : -Math.Pow(x, 2) - Math.Log(x) - Math.Log(Math.Sqrt(Math.PI));
+
+ // Log rules make subtraction of the non-log value non-trivial, this method simply subtracts the base value of 2 logs.
+ private double logDiff(double firstLog, double secondLog)
{
- if (x <= 5)
- return Math.Log(SpecialFunctions.Erfc(x));
+ double maxVal = Math.Max(firstLog, secondLog);
- return -Math.Pow(x, 2) - Math.Log(x) - Math.Log(Math.Sqrt(Math.PI));
+ // Avoid negative infinity - negative infinity (NaN) by checking if the higher value is negative infinity.
+ // Shouldn't ever happen, but good for redundancy purposes.
+ if (double.IsNegativeInfinity(maxVal))
+ {
+ return maxVal;
+ }
+
+ return firstLog + SpecialFunctions.Log1p(-Math.Exp(-(firstLog - secondLog)));
}
-
- private double logDiff(double l1, double l2) => l1 + SpecialFunctions.Log1p(-Math.Exp(-(l1 - l2)));
}
}
From adf16187b1d0e1ceb2520f5a3eccb7551ce7047a Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Wed, 22 Feb 2023 21:03:02 -0500
Subject: [PATCH 043/924] Change accuracy scaling
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 84b71a98d4..88c26e9e6a 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -107,7 +107,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (attributes.GreatHitWindow <= 0 || estimatedUr == null)
return 0;
- double accuracyValue = Math.Pow(75 / estimatedUr.Value, 1.1) * Math.Pow(attributes.StarRating / 2.7, 0.8) * 100.0;
+ double accuracyValue = Math.Pow(60 / estimatedUr.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
From 858afcd0b3ecdd10869cf540bcd7d79a9e8b1b22 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Mon, 20 Mar 2023 22:00:33 -0400
Subject: [PATCH 044/924] Pass OK hit window as a separate difficulty
attribute, fix erfc approximation
---
.../Difficulty/TaikoDifficultyAttributes.cs | 9 +++++++++
.../Difficulty/TaikoDifficultyCalculator.cs | 1 +
.../Difficulty/TaikoPerformanceCalculator.cs | 18 ++++++------------
3 files changed, 16 insertions(+), 12 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs
index 72452e27b3..f5c9280590 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs
@@ -43,6 +43,15 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
[JsonProperty("great_hit_window")]
public double GreatHitWindow { get; set; }
+ ///
+ /// The perceived hit window for an OK hit inclusive of rate-adjusting mods (DT/HT/etc).
+ ///
+ ///
+ /// Rate-adjusting mods don't directly affect the hit window, but have a perceived effect as a result of adjusting audio timing.
+ ///
+ [JsonProperty("ok_hit_window")]
+ public double OkHitWindow { get; set; }
+
public override IEnumerable<(int attributeId, object value)> ToDatabaseAttributes()
{
foreach (var v in base.ToDatabaseAttributes())
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
index 24b5f5939a..90bcb74533 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
@@ -95,6 +95,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
ColourDifficulty = colourRating,
PeakDifficulty = combinedRating,
GreatHitWindow = hitWindows.WindowFor(HitResult.Great) / clockRate,
+ OkHitWindow = hitWindows.WindowFor(HitResult.Ok) / clockRate,
MaxCombo = beatmap.HitObjects.Count(h => h is Hit),
};
}
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 88c26e9e6a..e430616d54 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -12,8 +12,6 @@ using osu.Game.Rulesets.Scoring;
using osu.Game.Rulesets.Taiko.Objects;
using osu.Game.Scoring;
using MathNet.Numerics;
-using osu.Framework.Audio.Track;
-using osu.Framework.Extensions.IEnumerableExtensions;
namespace osu.Game.Rulesets.Taiko.Difficulty
{
@@ -125,17 +123,11 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
///
private double? computeEstimatedUr(ScoreInfo score, TaikoDifficultyAttributes attributes)
{
- if (totalSuccessfulHits == 0 || attributes.GreatHitWindow == 0)
+ if (totalSuccessfulHits == 0 || attributes.GreatHitWindow <= 0)
return null;
- // Create a new track to properly calculate the hit window of 100s.
- var track = new TrackVirtual(10000);
- score.Mods.OfType().ForEach(m => m.ApplyToTrack(track));
- double clockRate = track.Rate;
-
- double overallDifficulty = (50 - attributes.GreatHitWindow * clockRate) / 3;
double h300 = attributes.GreatHitWindow;
- double h100 = overallDifficulty <= 5 ? (120 - 8 * overallDifficulty) / clockRate : (80 - 6 * (overallDifficulty - 5)) / clockRate;
+ double h100 = attributes.OkHitWindow;
// Returns the likelihood of a deviation resulting in the score's hit judgements. The peak of the curve is the most likely deviation.
double likelihoodGradient(double d)
@@ -167,8 +159,10 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
private double logPcHit(double x, double deviation) => logErfcApprox(x / (deviation * Math.Sqrt(2)));
- // There is a numerical approximation to increase how far you can calculate Erfc(x).
- private double logErfcApprox(double x) => x <= 5 ? Math.Log(SpecialFunctions.Erfc(x)) : -Math.Pow(x, 2) - Math.Log(x) - Math.Log(Math.Sqrt(Math.PI));
+ // There's a numerical approximation to increase how far you can calculate ln(erfc(x)).
+ private double logErfcApprox(double x) => x <= 5
+ ? Math.Log(SpecialFunctions.Erfc(x))
+ : -Math.Pow(x, 2) - Math.Log(x * Math.Sqrt(Math.PI)); // https://www.desmos.com/calculator/kdbxwxgf01
// Log rules make subtraction of the non-log value non-trivial, this method simply subtracts the base value of 2 logs.
private double logDiff(double firstLog, double secondLog)
From 9aa11e00905452f9181755f3997d517c84c3365b Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Mon, 20 Mar 2023 23:13:33 -0400
Subject: [PATCH 045/924] update desmos
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index e430616d54..be250f3b80 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -119,7 +119,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
///
/// Estimates the player's tap deviation based on the OD, number of objects, and number of 300s, 100s, and misses,
/// assuming the player's mean hit error is 0. The estimation is consistent in that two SS scores on the same map with the same settings
- /// will always return the same deviation. See: https://www.desmos.com/calculator/qlr946netu
+ /// will always return the same deviation. See: https://www.desmos.com/calculator/x3mvtir093
///
private double? computeEstimatedUr(ScoreInfo score, TaikoDifficultyAttributes attributes)
{
From 31c8cf09332410866c994586f38483d55010c3a2 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Thu, 27 Jul 2023 22:44:56 -0400
Subject: [PATCH 046/924] Buff accuracy scaling
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index a38eaf6a31..39246f962c 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (attributes.GreatHitWindow <= 0 || estimatedUr == null)
return 0;
- double accuracyValue = Math.Pow(60 / estimatedUr.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
+ double accuracyValue = Math.Pow(70 / estimatedUr.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 110.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
From 4de024675c1738d788238d66e88605ff5652159e Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Thu, 27 Jul 2023 23:02:07 -0400
Subject: [PATCH 047/924] Make comments more professional
---
.../Difficulty/TaikoPerformanceCalculator.cs | 14 ++++++--------
1 file changed, 6 insertions(+), 8 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 39246f962c..f5cdb02c82 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -115,9 +115,8 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
}
///
- /// Estimates the player's tap deviation based on the OD, number of objects, and number of 300s, 100s, and misses,
- /// assuming the player's mean hit error is 0. The estimation is consistent in that two SS scores on the same map with the same settings
- /// will always return the same deviation. See: https://www.desmos.com/calculator/x3mvtir093
+ /// Calculates the tap deviation for a player using the OD, object count, and scores of 300s, 100s, and misses, with an assumed mean hit error of 0.
+ /// Consistency is ensured as identical SS scores on the same map and settings yield the same deviation.
///
private double? computeEstimatedUr(ScoreInfo score, TaikoDifficultyAttributes attributes)
{
@@ -127,7 +126,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
double h300 = attributes.GreatHitWindow;
double h100 = attributes.OkHitWindow;
- // Returns the likelihood of a deviation resulting in the score's hit judgements. The peak of the curve is the most likely deviation.
+ // Determines the probability of a deviation leading to the score's hit evaluations. The curve's apex represents the most probable deviation.
double likelihoodGradient(double d)
{
if (d <= 0)
@@ -157,18 +156,17 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
private double logPcHit(double x, double deviation) => logErfcApprox(x / (deviation * Math.Sqrt(2)));
- // There's a numerical approximation to increase how far you can calculate ln(erfc(x)).
+ // Utilises a numerical approximation to extend the computation range of ln(erfc(x)).
private double logErfcApprox(double x) => x <= 5
? Math.Log(SpecialFunctions.Erfc(x))
: -Math.Pow(x, 2) - Math.Log(x * Math.Sqrt(Math.PI)); // https://www.desmos.com/calculator/kdbxwxgf01
- // Log rules make subtraction of the non-log value non-trivial, this method simply subtracts the base value of 2 logs.
+ // Subtracts the base value of two logs, circumventing log rules that typically complicate subtraction of non-logarithmic values.
private double logDiff(double firstLog, double secondLog)
{
double maxVal = Math.Max(firstLog, secondLog);
- // Avoid negative infinity - negative infinity (NaN) by checking if the higher value is negative infinity.
- // Shouldn't ever happen, but good for redundancy purposes.
+ // To avoid a NaN result, a check is performed to prevent subtraction of two negative infinity values.
if (double.IsNegativeInfinity(maxVal))
{
return maxVal;
From e56942012cf24981d517ec3d50128412feb7e76b Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Fri, 28 Jul 2023 11:38:30 -0400
Subject: [PATCH 048/924] Serialize ok hit window attribute to db
---
osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs | 2 ++
osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs | 1 +
2 files changed, 3 insertions(+)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs
index 9d498d705a..451aed183d 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyAttributes.cs
@@ -59,6 +59,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
yield return (ATTRIB_ID_DIFFICULTY, StarRating);
yield return (ATTRIB_ID_GREAT_HIT_WINDOW, GreatHitWindow);
+ yield return (ATTRIB_ID_OK_HIT_WINDOW, OkHitWindow);
}
public override void FromDatabaseAttributes(IReadOnlyDictionary values, IBeatmapOnlineInfo onlineInfo)
@@ -67,6 +68,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
StarRating = values[ATTRIB_ID_DIFFICULTY];
GreatHitWindow = values[ATTRIB_ID_GREAT_HIT_WINDOW];
+ OkHitWindow = values[ATTRIB_ID_OK_HIT_WINDOW];
}
}
}
diff --git a/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs b/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs
index 5a01faa417..b21b2cf567 100644
--- a/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs
+++ b/osu.Game/Rulesets/Difficulty/DifficultyAttributes.cs
@@ -30,6 +30,7 @@ namespace osu.Game.Rulesets.Difficulty
protected const int ATTRIB_ID_LEGACY_ACCURACY_SCORE = 23;
protected const int ATTRIB_ID_LEGACY_COMBO_SCORE = 25;
protected const int ATTRIB_ID_LEGACY_BONUS_SCORE_RATIO = 27;
+ protected const int ATTRIB_ID_OK_HIT_WINDOW = 29;
///
/// The mods which were applied to the beatmap.
From 5f0020b0ca05aceeb6102d076dd7c3dfa8d59dd2 Mon Sep 17 00:00:00 2001
From: Natelytle
Date: Sun, 30 Jul 2023 20:14:15 -0400
Subject: [PATCH 049/924] Reduce accuracy scaling
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index af988ef2d1..723a6612bc 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (attributes.GreatHitWindow <= 0 || estimatedUr == null)
return 0;
- double accuracyValue = Math.Pow(70 / estimatedUr.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 110.0;
+ double accuracyValue = Math.Pow(65 / estimatedUr.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
From e803b0215f146e449f12a77fae1f09db4fdae30f Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sat, 30 Dec 2023 01:38:08 +0100
Subject: [PATCH 050/924] flip along grid axis
---
.../Edit/OsuSelectionHandler.cs | 19 ++++++++++---------
osu.Game/Utils/GeometryUtils.cs | 11 +++++++++++
2 files changed, 21 insertions(+), 9 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
index cea2adc6e2..021c735ebd 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
@@ -1,6 +1,7 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
+using System;
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Allocation;
@@ -15,7 +16,6 @@ using osu.Game.Rulesets.Edit;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Objects.Types;
using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.UI;
using osu.Game.Screens.Edit.Compose.Components;
using osu.Game.Utils;
using osuTK;
@@ -28,6 +28,9 @@ namespace osu.Game.Rulesets.Osu.Edit
[Resolved(CanBeNull = true)]
private IDistanceSnapProvider? snapProvider { get; set; }
+ [Resolved]
+ private OsuGridToolboxGroup gridToolbox { get; set; } = null!;
+
///
/// During a transform, the initial path types of a single selected slider are stored so they
/// can be maintained throughout the operation.
@@ -104,13 +107,16 @@ namespace osu.Game.Rulesets.Osu.Edit
{
var hitObjects = selectedMovableObjects;
- var flipQuad = flipOverOrigin ? new Quad(0, 0, OsuPlayfield.BASE_SIZE.X, OsuPlayfield.BASE_SIZE.Y) : GeometryUtils.GetSurroundingQuad(hitObjects);
+ var flipQuad = flipOverOrigin ? new Quad(gridToolbox.StartPositionX.Value, gridToolbox.StartPositionY.Value, 0, 0) : GeometryUtils.GetSurroundingQuad(hitObjects);
+ var flipAxis = flipOverOrigin ? new Vector2(MathF.Cos(MathHelper.DegreesToRadians(gridToolbox.GridLinesRotation.Value)), MathF.Sin(MathHelper.DegreesToRadians(gridToolbox.GridLinesRotation.Value))) : Vector2.UnitX;
+ flipAxis = direction == Direction.Vertical ? flipAxis.PerpendicularLeft : flipAxis;
+ var controlPointFlipQuad = new Quad();
bool didFlip = false;
foreach (var h in hitObjects)
{
- var flippedPosition = GeometryUtils.GetFlippedPosition(direction, flipQuad, h.Position);
+ var flippedPosition = GeometryUtils.GetFlippedPosition(flipAxis, flipQuad, h.Position);
if (!Precision.AlmostEquals(flippedPosition, h.Position))
{
@@ -123,12 +129,7 @@ namespace osu.Game.Rulesets.Osu.Edit
didFlip = true;
foreach (var cp in slider.Path.ControlPoints)
- {
- cp.Position = new Vector2(
- (direction == Direction.Horizontal ? -1 : 1) * cp.Position.X,
- (direction == Direction.Vertical ? -1 : 1) * cp.Position.Y
- );
- }
+ cp.Position = GeometryUtils.GetFlippedPosition(flipAxis, controlPointFlipQuad, cp.Position);
}
}
diff --git a/osu.Game/Utils/GeometryUtils.cs b/osu.Game/Utils/GeometryUtils.cs
index e0d217dd48..aacf9b91f9 100644
--- a/osu.Game/Utils/GeometryUtils.cs
+++ b/osu.Game/Utils/GeometryUtils.cs
@@ -70,6 +70,17 @@ namespace osu.Game.Utils
return position;
}
+ ///
+ /// Given a flip axis vector, a surrounding quad for all selected objects, and a position,
+ /// will return the flipped position in screen space coordinates.
+ ///
+ public static Vector2 GetFlippedPosition(Vector2 axis, Quad quad, Vector2 position)
+ {
+ var centre = quad.Centre;
+
+ return position - 2 * Vector2.Dot(position - centre, axis) * axis;
+ }
+
///
/// Given a scale vector, a surrounding quad for all selected objects, and a position,
/// will return the scaled position in screen space coordinates.
From 078fe5a78ca5b0744d12c6f4fa8f242a0730986c Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sat, 30 Dec 2023 01:53:19 +0100
Subject: [PATCH 051/924] Rotate popover rotates around grid center
---
osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs | 2 +-
osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs | 8 +++++---
osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs | 4 +++-
3 files changed, 9 insertions(+), 5 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
index 84d5adbc52..02e98d75a7 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
@@ -104,7 +104,7 @@ namespace osu.Game.Rulesets.Osu.Edit
RightToolbox.AddRange(new EditorToolboxGroup[]
{
OsuGridToolboxGroup,
- new TransformToolboxGroup { RotationHandler = BlueprintContainer.SelectionHandler.RotationHandler, },
+ new TransformToolboxGroup { RotationHandler = BlueprintContainer.SelectionHandler.RotationHandler, GridToolbox = OsuGridToolboxGroup },
FreehandlSliderToolboxGroup
}
);
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
index f09d6b78e6..02a8ff5872 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
@@ -8,7 +8,6 @@ using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites;
using osu.Game.Graphics.UserInterfaceV2;
-using osu.Game.Rulesets.Osu.UI;
using osu.Game.Screens.Edit.Components.RadioButtons;
using osu.Game.Screens.Edit.Compose.Components;
using osuTK;
@@ -19,14 +18,17 @@ namespace osu.Game.Rulesets.Osu.Edit
{
private readonly SelectionRotationHandler rotationHandler;
+ private readonly OsuGridToolboxGroup gridToolbox;
+
private readonly Bindable rotationInfo = new Bindable(new PreciseRotationInfo(0, RotationOrigin.PlayfieldCentre));
private SliderWithTextBoxInput angleInput = null!;
private EditorRadioButtonCollection rotationOrigin = null!;
- public PreciseRotationPopover(SelectionRotationHandler rotationHandler)
+ public PreciseRotationPopover(SelectionRotationHandler rotationHandler, OsuGridToolboxGroup gridToolbox)
{
this.rotationHandler = rotationHandler;
+ this.gridToolbox = gridToolbox;
AllowableAnchors = new[] { Anchor.CentreLeft, Anchor.CentreRight };
}
@@ -78,7 +80,7 @@ namespace osu.Game.Rulesets.Osu.Edit
rotationInfo.BindValueChanged(rotation =>
{
- rotationHandler.Update(rotation.NewValue.Degrees, rotation.NewValue.Origin == RotationOrigin.PlayfieldCentre ? OsuPlayfield.BASE_SIZE / 2 : null);
+ rotationHandler.Update(rotation.NewValue.Degrees, rotation.NewValue.Origin == RotationOrigin.PlayfieldCentre ? gridToolbox.StartPosition.Value : null);
});
}
diff --git a/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs b/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
index 3da9f5b69b..f8df45f545 100644
--- a/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
+++ b/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
@@ -24,6 +24,8 @@ namespace osu.Game.Rulesets.Osu.Edit
public SelectionRotationHandler RotationHandler { get; init; } = null!;
+ public OsuGridToolboxGroup GridToolbox { get; init; } = null!;
+
public TransformToolboxGroup()
: base("transform")
{
@@ -41,7 +43,7 @@ namespace osu.Game.Rulesets.Osu.Edit
{
rotateButton = new EditorToolButton("Rotate",
() => new SpriteIcon { Icon = FontAwesome.Solid.Undo },
- () => new PreciseRotationPopover(RotationHandler)),
+ () => new PreciseRotationPopover(RotationHandler, GridToolbox)),
// TODO: scale
}
};
From 09852bc46b6b0b7a78914e19ba3414efab60afdd Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 31 Dec 2023 21:23:13 +0100
Subject: [PATCH 052/924] fix horizontal vs vertical flips being mixed up when
rotation angle is too big
---
osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
index 021c735ebd..1cb206c2f8 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
@@ -1,7 +1,6 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
-using System;
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Allocation;
@@ -107,9 +106,13 @@ namespace osu.Game.Rulesets.Osu.Edit
{
var hitObjects = selectedMovableObjects;
+ // If we're flipping over the origin, we take the grid origin position from the grid toolbox.
var flipQuad = flipOverOrigin ? new Quad(gridToolbox.StartPositionX.Value, gridToolbox.StartPositionY.Value, 0, 0) : GeometryUtils.GetSurroundingQuad(hitObjects);
- var flipAxis = flipOverOrigin ? new Vector2(MathF.Cos(MathHelper.DegreesToRadians(gridToolbox.GridLinesRotation.Value)), MathF.Sin(MathHelper.DegreesToRadians(gridToolbox.GridLinesRotation.Value))) : Vector2.UnitX;
+ // If we're flipping over the origin, we take the grid rotation from the grid toolbox.
+ // We want to normalize the rotation angle to -45 to 45 degrees, so horizontal vs vertical flip is not mixed up by the rotation and it stays intuitive to use.
+ var flipAxis = flipOverOrigin ? GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 405) % 90 - 45)) : Vector2.UnitX;
flipAxis = direction == Direction.Vertical ? flipAxis.PerpendicularLeft : flipAxis;
+
var controlPointFlipQuad = new Quad();
bool didFlip = false;
From 3495510c7b651efee091bad375591b2aa7875102 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sat, 30 Dec 2023 19:16:05 +0100
Subject: [PATCH 053/924] kinda working grid from points
---
.../Edit/OsuBlueprintContainer.cs | 42 +++++++++++++++++++
.../Edit/OsuGridToolboxGroup.cs | 21 ++++++++++
2 files changed, 63 insertions(+)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs b/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
index 54c54fca17..8b391cd06e 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
@@ -1,6 +1,8 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
+using osu.Framework.Allocation;
+using osu.Framework.Input.Events;
using osu.Game.Rulesets.Edit;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
@@ -8,16 +10,26 @@ using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners;
using osu.Game.Rulesets.Osu.Objects;
using osu.Game.Screens.Edit.Compose.Components;
+using osuTK;
namespace osu.Game.Rulesets.Osu.Edit
{
public partial class OsuBlueprintContainer : ComposeBlueprintContainer
{
+ private OsuGridToolboxGroup gridToolbox = null!;
+
public OsuBlueprintContainer(HitObjectComposer composer)
: base(composer)
{
}
+ [BackgroundDependencyLoader]
+ private void load(OsuGridToolboxGroup gridToolbox)
+ {
+ this.gridToolbox = gridToolbox;
+ gridToolbox.GridFromPointsClicked += OnGridFromPointsClicked;
+ }
+
protected override SelectionHandler CreateSelectionHandler() => new OsuSelectionHandler();
public override HitObjectSelectionBlueprint? CreateHitObjectBlueprintFor(HitObject hitObject)
@@ -36,5 +48,35 @@ namespace osu.Game.Rulesets.Osu.Edit
return base.CreateHitObjectBlueprintFor(hitObject);
}
+
+ private bool isPlacingGridFromPoints;
+ private Vector2? gridFromPointsStart;
+
+ private void OnGridFromPointsClicked()
+ {
+ isPlacingGridFromPoints = true;
+ gridFromPointsStart = null;
+ }
+
+ protected override bool OnClick(ClickEvent e)
+ {
+ if (!isPlacingGridFromPoints)
+ return base.OnClick(e);
+
+ var pos = ToLocalSpace(Composer.FindSnappedPositionAndTime(e.ScreenSpaceMousePosition).ScreenSpacePosition);
+
+ if (!gridFromPointsStart.HasValue)
+ {
+ gridFromPointsStart = pos;
+ }
+ else
+ {
+ gridToolbox.SetGridFromPoints(gridFromPointsStart.Value, pos);
+ isPlacingGridFromPoints = false;
+ gridFromPointsStart = null;
+ }
+
+ return true;
+ }
}
}
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
index 76e735449a..05b90696a0 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
@@ -1,6 +1,7 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
+using System;
using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
@@ -12,6 +13,7 @@ using osu.Framework.Input.Bindings;
using osu.Framework.Input.Events;
using osu.Game.Graphics.Containers;
using osu.Game.Graphics.UserInterface;
+using osu.Game.Graphics.UserInterfaceV2;
using osu.Game.Input.Bindings;
using osu.Game.Rulesets.Edit;
using osu.Game.Rulesets.Osu.UI;
@@ -90,6 +92,8 @@ namespace osu.Game.Rulesets.Osu.Edit
private ExpandableSlider gridLinesRotationSlider = null!;
private EditorRadioButtonCollection gridTypeButtons = null!;
+ public event Action? GridFromPointsClicked;
+
public OsuGridToolboxGroup()
: base("grid")
{
@@ -97,6 +101,17 @@ namespace osu.Game.Rulesets.Osu.Edit
private const float max_automatic_spacing = 64;
+ public void SetGridFromPoints(Vector2 point1, Vector2 point2)
+ {
+ StartPositionX.Value = point1.X;
+ StartPositionY.Value = point1.Y;
+ GridLinesRotation.Value = (MathHelper.RadiansToDegrees(MathF.Atan2(point2.Y - point1.Y, point2.X - point1.X)) + 405) % 90 - 45;
+ float dist = Vector2.Distance(point1, point2);
+ while (dist > Spacing.MaxValue)
+ dist /= 2;
+ Spacing.Value = dist;
+ }
+
[BackgroundDependencyLoader]
private void load()
{
@@ -129,6 +144,12 @@ namespace osu.Game.Rulesets.Osu.Edit
Spacing = new Vector2(0f, 10f),
Children = new Drawable[]
{
+ new RoundedButton
+ {
+ Action = () => GridFromPointsClicked?.Invoke(),
+ RelativeSizeAxes = Axes.X,
+ Text = "Grid from points",
+ },
gridTypeButtons = new EditorRadioButtonCollection
{
RelativeSizeAxes = Axes.X,
From fea0ceb49899643371e5f81bf32ccf74fac560df Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sat, 30 Dec 2023 20:22:14 +0100
Subject: [PATCH 054/924] improve the grid from points
---
.../Edit/OsuBlueprintContainer.cs | 26 ++++++++++++++-
.../Edit/OsuGridToolboxGroup.cs | 32 ++++++++++++-------
2 files changed, 45 insertions(+), 13 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs b/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
index 8b391cd06e..79b6fafcab 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
@@ -58,12 +58,17 @@ namespace osu.Game.Rulesets.Osu.Edit
gridFromPointsStart = null;
}
+ protected override bool OnMouseDown(MouseDownEvent e)
+ {
+ return isPlacingGridFromPoints || base.OnMouseDown(e);
+ }
+
protected override bool OnClick(ClickEvent e)
{
if (!isPlacingGridFromPoints)
return base.OnClick(e);
- var pos = ToLocalSpace(Composer.FindSnappedPositionAndTime(e.ScreenSpaceMousePosition).ScreenSpacePosition);
+ var pos = ToLocalSpace(Composer.FindSnappedPositionAndTime(e.ScreenSpaceMousePosition, ~SnapType.GlobalGrids).ScreenSpacePosition);
if (!gridFromPointsStart.HasValue)
{
@@ -78,5 +83,24 @@ namespace osu.Game.Rulesets.Osu.Edit
return true;
}
+
+ protected override bool OnMouseMove(MouseMoveEvent e)
+ {
+ if (!isPlacingGridFromPoints)
+ return base.OnMouseMove(e);
+
+ var pos = ToLocalSpace(Composer.FindSnappedPositionAndTime(e.ScreenSpaceMousePosition, ~SnapType.GlobalGrids).ScreenSpacePosition);
+
+ if (!gridFromPointsStart.HasValue)
+ {
+ gridToolbox.StartPosition.Value = pos;
+ }
+ else
+ {
+ gridToolbox.SetGridFromPoints(gridFromPointsStart.Value, pos);
+ }
+
+ return true;
+ }
}
}
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
index 05b90696a0..b07d8dcd56 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
@@ -39,7 +39,6 @@ namespace osu.Game.Rulesets.Osu.Edit
{
MinValue = 0f,
MaxValue = OsuPlayfield.BASE_SIZE.X,
- Precision = 1f
};
///
@@ -49,7 +48,6 @@ namespace osu.Game.Rulesets.Osu.Edit
{
MinValue = 0f,
MaxValue = OsuPlayfield.BASE_SIZE.Y,
- Precision = 1f
};
///
@@ -59,7 +57,6 @@ namespace osu.Game.Rulesets.Osu.Edit
{
MinValue = 4f,
MaxValue = 128f,
- Precision = 1f
};
///
@@ -69,7 +66,6 @@ namespace osu.Game.Rulesets.Osu.Edit
{
MinValue = -45f,
MaxValue = 45f,
- Precision = 1f
};
///
@@ -105,9 +101,15 @@ namespace osu.Game.Rulesets.Osu.Edit
{
StartPositionX.Value = point1.X;
StartPositionY.Value = point1.Y;
- GridLinesRotation.Value = (MathHelper.RadiansToDegrees(MathF.Atan2(point2.Y - point1.Y, point2.X - point1.X)) + 405) % 90 - 45;
+
+ // Get the angle between the two points and normalize to the valid range.
+ float period = GridType.Value == PositionSnapGridType.Triangle ? 60 : 90;
+ GridLinesRotation.Value = (MathHelper.RadiansToDegrees(MathF.Atan2(point2.Y - point1.Y, point2.X - point1.X))
+ + 360 + period / 2) % period - period / 2;
+
+ // Divide the distance so that there is a good density of grid lines.
float dist = Vector2.Distance(point1, point2);
- while (dist > Spacing.MaxValue)
+ while (dist > 32)
dist /= 2;
Spacing.Value = dist;
}
@@ -181,22 +183,28 @@ namespace osu.Game.Rulesets.Osu.Edit
StartPositionX.BindValueChanged(x =>
{
- startPositionXSlider.ContractedLabelText = $"X: {x.NewValue:N0}";
- startPositionXSlider.ExpandedLabelText = $"X Offset: {x.NewValue:N0}";
+ startPositionXSlider.ContractedLabelText = $"X: {x.NewValue:#,0.##}";
+ startPositionXSlider.ExpandedLabelText = $"X Offset: {x.NewValue:#,0.##}";
StartPosition.Value = new Vector2(x.NewValue, StartPosition.Value.Y);
}, true);
StartPositionY.BindValueChanged(y =>
{
- startPositionYSlider.ContractedLabelText = $"Y: {y.NewValue:N0}";
- startPositionYSlider.ExpandedLabelText = $"Y Offset: {y.NewValue:N0}";
+ startPositionYSlider.ContractedLabelText = $"Y: {y.NewValue:#,0.##}";
+ startPositionYSlider.ExpandedLabelText = $"Y Offset: {y.NewValue:#,0.##}";
StartPosition.Value = new Vector2(StartPosition.Value.X, y.NewValue);
}, true);
+ StartPosition.BindValueChanged(pos =>
+ {
+ StartPositionX.Value = pos.NewValue.X;
+ StartPositionY.Value = pos.NewValue.Y;
+ });
+
Spacing.BindValueChanged(spacing =>
{
- spacingSlider.ContractedLabelText = $"S: {spacing.NewValue:N0}";
- spacingSlider.ExpandedLabelText = $"Spacing: {spacing.NewValue:N0}";
+ spacingSlider.ContractedLabelText = $"S: {spacing.NewValue:#,0.##}";
+ spacingSlider.ExpandedLabelText = $"Spacing: {spacing.NewValue:#,0.##}";
SpacingVector.Value = new Vector2(spacing.NewValue);
editorBeatmap.BeatmapInfo.GridSize = (int)spacing.NewValue;
}, true);
From c2ea1848ca96c580f36cef4393c2dd5c145f03c1 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sat, 30 Dec 2023 20:58:21 +0100
Subject: [PATCH 055/924] fix period
---
osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
index b07d8dcd56..31148f10a2 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
@@ -64,8 +64,8 @@ namespace osu.Game.Rulesets.Osu.Edit
///
public BindableFloat GridLinesRotation { get; } = new BindableFloat(0f)
{
- MinValue = -45f,
- MaxValue = 45f,
+ MinValue = -90f,
+ MaxValue = 90f,
};
///
@@ -103,9 +103,9 @@ namespace osu.Game.Rulesets.Osu.Edit
StartPositionY.Value = point1.Y;
// Get the angle between the two points and normalize to the valid range.
- float period = GridType.Value == PositionSnapGridType.Triangle ? 60 : 90;
+ const float period = 180;
GridLinesRotation.Value = (MathHelper.RadiansToDegrees(MathF.Atan2(point2.Y - point1.Y, point2.X - point1.X))
- + 360 + period / 2) % period - period / 2;
+ + period * 1.5f) % period - period * 0.5f;
// Divide the distance so that there is a good density of grid lines.
float dist = Vector2.Distance(point1, point2);
From c952e2f6209ff0cffa7b7db01266baf2cdab73d3 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 31 Dec 2023 02:12:50 +0100
Subject: [PATCH 056/924] deselect stuff stuff when grid from points
---
osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs | 3 +++
1 file changed, 3 insertions(+)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs b/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
index 79b6fafcab..a5f7185a7d 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
@@ -56,6 +56,9 @@ namespace osu.Game.Rulesets.Osu.Edit
{
isPlacingGridFromPoints = true;
gridFromPointsStart = null;
+
+ // Deselect all objects because we cant snap to objects which are selected.
+ DeselectAll();
}
protected override bool OnMouseDown(MouseDownEvent e)
From 7a0535a2ebe1e612691f16ced09137feb1aa9da3 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 31 Dec 2023 02:26:14 +0100
Subject: [PATCH 057/924] add right click for abort
---
.../Edit/OsuBlueprintContainer.cs | 24 +++++++------------
1 file changed, 9 insertions(+), 15 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs b/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
index a5f7185a7d..45cf754c57 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
@@ -11,6 +11,7 @@ using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners;
using osu.Game.Rulesets.Osu.Objects;
using osu.Game.Screens.Edit.Compose.Components;
using osuTK;
+using osuTK.Input;
namespace osu.Game.Rulesets.Osu.Edit
{
@@ -62,28 +63,23 @@ namespace osu.Game.Rulesets.Osu.Edit
}
protected override bool OnMouseDown(MouseDownEvent e)
- {
- return isPlacingGridFromPoints || base.OnMouseDown(e);
- }
-
- protected override bool OnClick(ClickEvent e)
{
if (!isPlacingGridFromPoints)
- return base.OnClick(e);
+ return base.OnMouseDown(e);
- var pos = ToLocalSpace(Composer.FindSnappedPositionAndTime(e.ScreenSpaceMousePosition, ~SnapType.GlobalGrids).ScreenSpacePosition);
+ var pos = snappedLocalPosition(e);
if (!gridFromPointsStart.HasValue)
- {
gridFromPointsStart = pos;
- }
else
{
gridToolbox.SetGridFromPoints(gridFromPointsStart.Value, pos);
isPlacingGridFromPoints = false;
- gridFromPointsStart = null;
}
+ if (e.Button == MouseButton.Right)
+ isPlacingGridFromPoints = false;
+
return true;
}
@@ -92,18 +88,16 @@ namespace osu.Game.Rulesets.Osu.Edit
if (!isPlacingGridFromPoints)
return base.OnMouseMove(e);
- var pos = ToLocalSpace(Composer.FindSnappedPositionAndTime(e.ScreenSpaceMousePosition, ~SnapType.GlobalGrids).ScreenSpacePosition);
+ var pos = snappedLocalPosition(e);
if (!gridFromPointsStart.HasValue)
- {
gridToolbox.StartPosition.Value = pos;
- }
else
- {
gridToolbox.SetGridFromPoints(gridFromPointsStart.Value, pos);
- }
return true;
}
+
+ private Vector2 snappedLocalPosition(UIEvent e) => ToLocalSpace(Composer.FindSnappedPositionAndTime(e.ScreenSpaceMousePosition, ~SnapType.GlobalGrids).ScreenSpacePosition);
}
}
From 85bfd6137a5f286341a14615a9ac0ea1fee8137f Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 31 Dec 2023 03:53:42 +0100
Subject: [PATCH 058/924] improve UI
From 4e3fe5112d9d02171fb19e23bd26520f34590c87 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Mon, 1 Jan 2024 16:09:18 +0100
Subject: [PATCH 059/924] merge conflict fix
---
osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
index 31148f10a2..c318bac64d 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
@@ -86,6 +86,7 @@ namespace osu.Game.Rulesets.Osu.Edit
private ExpandableSlider startPositionYSlider = null!;
private ExpandableSlider spacingSlider = null!;
private ExpandableSlider gridLinesRotationSlider = null!;
+ private RoundedButton gridFromPointsButton = null!;
private EditorRadioButtonCollection gridTypeButtons = null!;
public event Action? GridFromPointsClicked;
@@ -146,7 +147,7 @@ namespace osu.Game.Rulesets.Osu.Edit
Spacing = new Vector2(0f, 10f),
Children = new Drawable[]
{
- new RoundedButton
+ gridFromPointsButton = new RoundedButton
{
Action = () => GridFromPointsClicked?.Invoke(),
RelativeSizeAxes = Axes.X,
@@ -217,6 +218,8 @@ namespace osu.Game.Rulesets.Osu.Edit
expandingContainer?.Expanded.BindValueChanged(v =>
{
+ gridFromPointsButton.FadeTo(v.NewValue ? 1f : 0f, 500, Easing.OutQuint);
+ gridFromPointsButton.BypassAutoSizeAxes = !v.NewValue ? Axes.Y : Axes.None;
gridTypeButtons.FadeTo(v.NewValue ? 1f : 0f, 500, Easing.OutQuint);
gridTypeButtons.BypassAutoSizeAxes = !v.NewValue ? Axes.Y : Axes.None;
}, true);
From 98505d0bba18fe4b08c06bf44d77298040c1c5e8 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 31 Dec 2023 18:58:29 +0100
Subject: [PATCH 060/924] improve grid from points tool code
---
.../Edit/GridFromPointsTool.cs | 72 +++++++++++++++++++
.../Edit/OsuBlueprintContainer.cs | 63 ----------------
.../Edit/OsuHitObjectComposer.cs | 18 +++--
osu.Game/Rulesets/Edit/HitObjectComposer.cs | 5 +-
4 files changed, 90 insertions(+), 68 deletions(-)
create mode 100644 osu.Game.Rulesets.Osu/Edit/GridFromPointsTool.cs
diff --git a/osu.Game.Rulesets.Osu/Edit/GridFromPointsTool.cs b/osu.Game.Rulesets.Osu/Edit/GridFromPointsTool.cs
new file mode 100644
index 0000000000..722d9d1303
--- /dev/null
+++ b/osu.Game.Rulesets.Osu/Edit/GridFromPointsTool.cs
@@ -0,0 +1,72 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Edit;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+ public partial class GridFromPointsTool : Drawable
+ {
+ [Resolved]
+ private OsuGridToolboxGroup gridToolboxGroup { get; set; } = null!;
+
+ [Resolved(canBeNull: true)]
+ private IPositionSnapProvider? snapProvider { get; set; }
+
+ public bool IsPlacing { get; private set; }
+
+ private Vector2? startPosition;
+
+ public void BeginPlacement()
+ {
+ IsPlacing = true;
+ startPosition = null;
+ }
+
+ protected override bool OnMouseDown(MouseDownEvent e)
+ {
+ if (!IsPlacing)
+ return base.OnMouseDown(e);
+
+ var pos = snappedLocalPosition(e);
+
+ if (!startPosition.HasValue)
+ startPosition = pos;
+ else
+ {
+ gridToolboxGroup.SetGridFromPoints(startPosition.Value, pos);
+ IsPlacing = false;
+ }
+
+ if (e.Button == MouseButton.Right)
+ IsPlacing = false;
+
+ return true;
+ }
+
+ protected override bool OnMouseMove(MouseMoveEvent e)
+ {
+ if (!IsPlacing)
+ return base.OnMouseMove(e);
+
+ var pos = snappedLocalPosition(e);
+
+ if (!startPosition.HasValue)
+ gridToolboxGroup.StartPosition.Value = pos;
+ else
+ gridToolboxGroup.SetGridFromPoints(startPosition.Value, pos);
+
+ return true;
+ }
+
+ private Vector2 snappedLocalPosition(UIEvent e)
+ {
+ return ToLocalSpace(snapProvider?.FindSnappedPositionAndTime(e.ScreenSpaceMousePosition, ~SnapType.GlobalGrids).ScreenSpacePosition ?? e.ScreenSpaceMousePosition);
+ }
+ }
+}
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs b/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
index 45cf754c57..54c54fca17 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuBlueprintContainer.cs
@@ -1,8 +1,6 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
-using osu.Framework.Allocation;
-using osu.Framework.Input.Events;
using osu.Game.Rulesets.Edit;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
@@ -10,27 +8,16 @@ using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners;
using osu.Game.Rulesets.Osu.Objects;
using osu.Game.Screens.Edit.Compose.Components;
-using osuTK;
-using osuTK.Input;
namespace osu.Game.Rulesets.Osu.Edit
{
public partial class OsuBlueprintContainer : ComposeBlueprintContainer
{
- private OsuGridToolboxGroup gridToolbox = null!;
-
public OsuBlueprintContainer(HitObjectComposer composer)
: base(composer)
{
}
- [BackgroundDependencyLoader]
- private void load(OsuGridToolboxGroup gridToolbox)
- {
- this.gridToolbox = gridToolbox;
- gridToolbox.GridFromPointsClicked += OnGridFromPointsClicked;
- }
-
protected override SelectionHandler CreateSelectionHandler() => new OsuSelectionHandler();
public override HitObjectSelectionBlueprint? CreateHitObjectBlueprintFor(HitObject hitObject)
@@ -49,55 +36,5 @@ namespace osu.Game.Rulesets.Osu.Edit
return base.CreateHitObjectBlueprintFor(hitObject);
}
-
- private bool isPlacingGridFromPoints;
- private Vector2? gridFromPointsStart;
-
- private void OnGridFromPointsClicked()
- {
- isPlacingGridFromPoints = true;
- gridFromPointsStart = null;
-
- // Deselect all objects because we cant snap to objects which are selected.
- DeselectAll();
- }
-
- protected override bool OnMouseDown(MouseDownEvent e)
- {
- if (!isPlacingGridFromPoints)
- return base.OnMouseDown(e);
-
- var pos = snappedLocalPosition(e);
-
- if (!gridFromPointsStart.HasValue)
- gridFromPointsStart = pos;
- else
- {
- gridToolbox.SetGridFromPoints(gridFromPointsStart.Value, pos);
- isPlacingGridFromPoints = false;
- }
-
- if (e.Button == MouseButton.Right)
- isPlacingGridFromPoints = false;
-
- return true;
- }
-
- protected override bool OnMouseMove(MouseMoveEvent e)
- {
- if (!isPlacingGridFromPoints)
- return base.OnMouseMove(e);
-
- var pos = snappedLocalPosition(e);
-
- if (!gridFromPointsStart.HasValue)
- gridToolbox.StartPosition.Value = pos;
- else
- gridToolbox.SetGridFromPoints(gridFromPointsStart.Value, pos);
-
- return true;
- }
-
- private Vector2 snappedLocalPosition(UIEvent e) => ToLocalSpace(Composer.FindSnappedPositionAndTime(e.ScreenSpaceMousePosition, ~SnapType.GlobalGrids).ScreenSpacePosition);
}
}
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
index 02e98d75a7..e035317194 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
@@ -81,13 +81,12 @@ namespace osu.Game.Rulesets.Osu.Edit
// Give a bit of breathing room around the playfield content.
PlayfieldContentContainer.Padding = new MarginPadding(10);
- LayerBelowRuleset.AddRange(new Drawable[]
- {
+ LayerBelowRuleset.Add(
distanceSnapGridContainer = new Container
{
RelativeSizeAxes = Axes.Both
}
- });
+ );
selectedHitObjects = EditorBeatmap.SelectedHitObjects.GetBoundCopy();
selectedHitObjects.CollectionChanged += (_, _) => updateDistanceSnapGrid();
@@ -100,6 +99,15 @@ namespace osu.Game.Rulesets.Osu.Edit
updateDistanceSnapGrid();
OsuGridToolboxGroup.GridType.BindValueChanged(updatePositionSnapGrid, true);
+ OsuGridToolboxGroup.GridFromPointsClicked += () => gridFromPointsTool.BeginPlacement();
+
+ LayerAboveRuleset.Add(
+ // Place it above the playfield and blueprints, so it takes priority when handling input.
+ gridFromPointsTool = new GridFromPointsTool
+ {
+ RelativeSizeAxes = Axes.Both,
+ }
+ );
RightToolbox.AddRange(new EditorToolboxGroup[]
{
@@ -110,6 +118,8 @@ namespace osu.Game.Rulesets.Osu.Edit
);
}
+ private GridFromPointsTool gridFromPointsTool;
+
private void updatePositionSnapGrid(ValueChangedEvent obj)
{
if (positionSnapGrid != null)
@@ -278,7 +288,7 @@ namespace osu.Game.Rulesets.Osu.Edit
foreach (var b in blueprints)
{
- if (b.IsSelected)
+ if (b.IsSelected && !gridFromPointsTool.IsPlacing)
continue;
var snapPositions = b.ScreenSpaceSnapPoints;
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index 50e6393895..4f8329cc82 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -76,6 +76,8 @@ namespace osu.Game.Rulesets.Edit
protected readonly Container LayerBelowRuleset = new Container { RelativeSizeAxes = Axes.Both };
+ protected readonly Container LayerAboveRuleset = new Container { RelativeSizeAxes = Axes.Both };
+
protected InputManager InputManager { get; private set; }
private EditorRadioButtonCollection toolboxCollection;
@@ -137,7 +139,8 @@ namespace osu.Game.Rulesets.Edit
drawableRulesetWrapper,
// layers above playfield
drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer()
- .WithChild(BlueprintContainer = CreateBlueprintContainer())
+ .WithChild(BlueprintContainer = CreateBlueprintContainer()),
+ drawableRulesetWrapper.CreatePlayfieldAdjustmentContainer().WithChild(LayerAboveRuleset),
}
},
new Container
From b54c9a36fea93e5bcf2ec3b05ac931eba5090c96 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 31 Dec 2023 19:08:27 +0100
Subject: [PATCH 061/924] move GridFromPointsClicked handler creation code
---
osu.Game.Rulesets.Osu/Edit/GridFromPointsTool.cs | 7 +++++++
osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs | 5 ++---
2 files changed, 9 insertions(+), 3 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/GridFromPointsTool.cs b/osu.Game.Rulesets.Osu/Edit/GridFromPointsTool.cs
index 722d9d1303..9bbeeaafc3 100644
--- a/osu.Game.Rulesets.Osu/Edit/GridFromPointsTool.cs
+++ b/osu.Game.Rulesets.Osu/Edit/GridFromPointsTool.cs
@@ -22,6 +22,13 @@ namespace osu.Game.Rulesets.Osu.Edit
private Vector2? startPosition;
+ protected override void LoadComplete()
+ {
+ base.LoadComplete();
+
+ gridToolboxGroup.GridFromPointsClicked += BeginPlacement;
+ }
+
public void BeginPlacement()
{
IsPlacing = true;
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
index e035317194..cd5c4f4ba9 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs
@@ -63,6 +63,8 @@ namespace osu.Game.Rulesets.Osu.Edit
private Bindable placementObject;
+ private GridFromPointsTool gridFromPointsTool;
+
[Cached(typeof(IDistanceSnapProvider))]
protected readonly OsuDistanceSnapProvider DistanceSnapProvider = new OsuDistanceSnapProvider();
@@ -99,7 +101,6 @@ namespace osu.Game.Rulesets.Osu.Edit
updateDistanceSnapGrid();
OsuGridToolboxGroup.GridType.BindValueChanged(updatePositionSnapGrid, true);
- OsuGridToolboxGroup.GridFromPointsClicked += () => gridFromPointsTool.BeginPlacement();
LayerAboveRuleset.Add(
// Place it above the playfield and blueprints, so it takes priority when handling input.
@@ -118,8 +119,6 @@ namespace osu.Game.Rulesets.Osu.Edit
);
}
- private GridFromPointsTool gridFromPointsTool;
-
private void updatePositionSnapGrid(ValueChangedEvent obj)
{
if (positionSnapGrid != null)
From f8979cff3aaf2c184f08d66fd6cc6f4aeb397f41 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Mon, 1 Jan 2024 16:14:20 +0100
Subject: [PATCH 062/924] fix distance
---
osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
index c318bac64d..b73eaecc66 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuGridToolboxGroup.cs
@@ -110,7 +110,7 @@ namespace osu.Game.Rulesets.Osu.Edit
// Divide the distance so that there is a good density of grid lines.
float dist = Vector2.Distance(point1, point2);
- while (dist > 32)
+ while (dist >= max_automatic_spacing)
dist /= 2;
Spacing.Value = dist;
}
From 236f029dad22722ebf73c02d40dc19b312b16642 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Thu, 1 Feb 2024 16:56:57 +0100
Subject: [PATCH 063/924] Remove Masking from PositionSnapGrid
This caused issues in rendering the outline of the grid because the outline was getting masked at some resolutions.
---
.../Components/LinedPositionSnapGrid.cs | 128 +++++++++++++++---
.../Compose/Components/PositionSnapGrid.cs | 2 -
2 files changed, 106 insertions(+), 24 deletions(-)
diff --git a/osu.Game/Screens/Edit/Compose/Components/LinedPositionSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/LinedPositionSnapGrid.cs
index ebdd76a4e2..8a7f6b5344 100644
--- a/osu.Game/Screens/Edit/Compose/Components/LinedPositionSnapGrid.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/LinedPositionSnapGrid.cs
@@ -15,18 +15,29 @@ namespace osu.Game.Screens.Edit.Compose.Components
{
protected void GenerateGridLines(Vector2 step, Vector2 drawSize)
{
+ if (Precision.AlmostEquals(step, Vector2.Zero))
+ return;
+
int index = 0;
- var currentPosition = StartPosition.Value;
// Make lines the same width independent of display resolution.
float lineWidth = DrawWidth / ScreenSpaceDrawQuad.Width;
- float lineLength = drawSize.Length * 2;
+ float rotation = MathHelper.RadiansToDegrees(MathF.Atan2(step.Y, step.X));
List generatedLines = new List();
- while (lineDefinitelyIntersectsBox(currentPosition, step.PerpendicularLeft, drawSize) ||
- isMovingTowardsBox(currentPosition, step, drawSize))
+ while (true)
{
+ Vector2 currentPosition = StartPosition.Value + index++ * step;
+
+ if (!lineDefinitelyIntersectsBox(currentPosition, step.PerpendicularLeft, drawSize, out var p1, out var p2))
+ {
+ if (!isMovingTowardsBox(currentPosition, step, drawSize))
+ break;
+
+ continue;
+ }
+
var gridLine = new Box
{
Colour = Colour4.White,
@@ -34,15 +45,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.None,
Width = lineWidth,
- Height = lineLength,
- Position = currentPosition,
- Rotation = MathHelper.RadiansToDegrees(MathF.Atan2(step.Y, step.X)),
+ Height = Vector2.Distance(p1, p2),
+ Position = (p1 + p2) / 2,
+ Rotation = rotation,
};
generatedLines.Add(gridLine);
-
- index += 1;
- currentPosition = StartPosition.Value + index * step;
}
if (generatedLines.Count == 0)
@@ -59,23 +67,99 @@ namespace osu.Game.Screens.Edit.Compose.Components
(currentPosition + step - box).LengthSquared < (currentPosition - box).LengthSquared;
}
- private bool lineDefinitelyIntersectsBox(Vector2 lineStart, Vector2 lineDir, Vector2 box)
+ ///
+ /// Determines if the line starting at and going in the direction of
+ /// definitely intersects the box on (0, 0) with the given width and height and returns the intersection points if it does.
+ ///
+ /// The start point of the line.
+ /// The direction of the line.
+ /// The width and height of the box.
+ /// The first intersection point.
+ /// The second intersection point.
+ /// Whether the line definitely intersects the box.
+ private bool lineDefinitelyIntersectsBox(Vector2 lineStart, Vector2 lineDir, Vector2 box, out Vector2 p1, out Vector2 p2)
{
- var p2 = lineStart + lineDir;
+ p1 = Vector2.Zero;
+ p2 = Vector2.Zero;
- double d1 = det(Vector2.Zero);
- double d2 = det(new Vector2(box.X, 0));
- double d3 = det(new Vector2(0, box.Y));
- double d4 = det(box);
+ if (Precision.AlmostEquals(lineDir.X, 0))
+ {
+ // If the line is vertical, we only need to check if the X coordinate of the line is within the box.
+ if (!Precision.DefinitelyBigger(lineStart.X, 0) || !Precision.DefinitelyBigger(box.X, lineStart.X))
+ return false;
- return definitelyDifferentSign(d1, d2) || definitelyDifferentSign(d3, d4) ||
- definitelyDifferentSign(d1, d3) || definitelyDifferentSign(d2, d4);
+ p1 = new Vector2(lineStart.X, 0);
+ p2 = new Vector2(lineStart.X, box.Y);
+ return true;
+ }
- double det(Vector2 p) => (p.X - lineStart.X) * (p2.Y - lineStart.Y) - (p.Y - lineStart.Y) * (p2.X - lineStart.X);
+ if (Precision.AlmostEquals(lineDir.Y, 0))
+ {
+ // If the line is horizontal, we only need to check if the Y coordinate of the line is within the box.
+ if (!Precision.DefinitelyBigger(lineStart.Y, 0) || !Precision.DefinitelyBigger(box.Y, lineStart.Y))
+ return false;
- bool definitelyDifferentSign(double a, double b) => !Precision.AlmostEquals(a, 0) &&
- !Precision.AlmostEquals(b, 0) &&
- Math.Sign(a) != Math.Sign(b);
+ p1 = new Vector2(0, lineStart.Y);
+ p2 = new Vector2(box.X, lineStart.Y);
+ return true;
+ }
+
+ float m = lineDir.Y / lineDir.X;
+ float mInv = lineDir.X / lineDir.Y; // Use this to improve numerical stability if X is close to zero.
+ float b = lineStart.Y - m * lineStart.X;
+
+ // Calculate intersection points with the sides of the box.
+ var p = new List(4);
+
+ if (0 <= b && b <= box.Y)
+ p.Add(new Vector2(0, b));
+ if (0 <= (box.Y - b) * mInv && (box.Y - b) * mInv <= box.X)
+ p.Add(new Vector2((box.Y - b) * mInv, box.Y));
+ if (0 <= m * box.X + b && m * box.X + b <= box.Y)
+ p.Add(new Vector2(box.X, m * box.X + b));
+ if (0 <= -b * mInv && -b * mInv <= box.X)
+ p.Add(new Vector2(-b * mInv, 0));
+
+ switch (p.Count)
+ {
+ case 4:
+ // If there are 4 intersection points, the line is a diagonal of the box.
+ if (m > 0)
+ {
+ p1 = Vector2.Zero;
+ p2 = box;
+ }
+ else
+ {
+ p1 = new Vector2(0, box.Y);
+ p2 = new Vector2(box.X, 0);
+ }
+
+ break;
+
+ case 3:
+ // If there are 3 intersection points, the line goes through a corner of the box.
+ if (p[0] == p[1])
+ {
+ p1 = p[0];
+ p2 = p[2];
+ }
+ else
+ {
+ p1 = p[0];
+ p2 = p[1];
+ }
+
+ break;
+
+ case 2:
+ p1 = p[0];
+ p2 = p[1];
+
+ break;
+ }
+
+ return !Precision.AlmostEquals(p1, p2);
}
}
}
diff --git a/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs
index 36687ef73a..e576ac1e49 100644
--- a/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs
@@ -21,8 +21,6 @@ namespace osu.Game.Screens.Edit.Compose.Components
protected PositionSnapGrid()
{
- Masking = true;
-
StartPosition.BindValueChanged(_ => GridCache.Invalidate());
AddLayout(GridCache);
From 2918ecf46c3516039a28f58d2dd71042d505f574 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Thu, 1 Feb 2024 16:56:57 +0100
Subject: [PATCH 064/924] Remove Masking from PositionSnapGrid
This caused issues in rendering the outline of the grid because the outline was getting masked at some resolutions.
---
.../Components/LinedPositionSnapGrid.cs | 128 +++++++++++++++---
.../Compose/Components/PositionSnapGrid.cs | 2 -
2 files changed, 106 insertions(+), 24 deletions(-)
diff --git a/osu.Game/Screens/Edit/Compose/Components/LinedPositionSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/LinedPositionSnapGrid.cs
index ebdd76a4e2..8a7f6b5344 100644
--- a/osu.Game/Screens/Edit/Compose/Components/LinedPositionSnapGrid.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/LinedPositionSnapGrid.cs
@@ -15,18 +15,29 @@ namespace osu.Game.Screens.Edit.Compose.Components
{
protected void GenerateGridLines(Vector2 step, Vector2 drawSize)
{
+ if (Precision.AlmostEquals(step, Vector2.Zero))
+ return;
+
int index = 0;
- var currentPosition = StartPosition.Value;
// Make lines the same width independent of display resolution.
float lineWidth = DrawWidth / ScreenSpaceDrawQuad.Width;
- float lineLength = drawSize.Length * 2;
+ float rotation = MathHelper.RadiansToDegrees(MathF.Atan2(step.Y, step.X));
List generatedLines = new List();
- while (lineDefinitelyIntersectsBox(currentPosition, step.PerpendicularLeft, drawSize) ||
- isMovingTowardsBox(currentPosition, step, drawSize))
+ while (true)
{
+ Vector2 currentPosition = StartPosition.Value + index++ * step;
+
+ if (!lineDefinitelyIntersectsBox(currentPosition, step.PerpendicularLeft, drawSize, out var p1, out var p2))
+ {
+ if (!isMovingTowardsBox(currentPosition, step, drawSize))
+ break;
+
+ continue;
+ }
+
var gridLine = new Box
{
Colour = Colour4.White,
@@ -34,15 +45,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.None,
Width = lineWidth,
- Height = lineLength,
- Position = currentPosition,
- Rotation = MathHelper.RadiansToDegrees(MathF.Atan2(step.Y, step.X)),
+ Height = Vector2.Distance(p1, p2),
+ Position = (p1 + p2) / 2,
+ Rotation = rotation,
};
generatedLines.Add(gridLine);
-
- index += 1;
- currentPosition = StartPosition.Value + index * step;
}
if (generatedLines.Count == 0)
@@ -59,23 +67,99 @@ namespace osu.Game.Screens.Edit.Compose.Components
(currentPosition + step - box).LengthSquared < (currentPosition - box).LengthSquared;
}
- private bool lineDefinitelyIntersectsBox(Vector2 lineStart, Vector2 lineDir, Vector2 box)
+ ///
+ /// Determines if the line starting at and going in the direction of
+ /// definitely intersects the box on (0, 0) with the given width and height and returns the intersection points if it does.
+ ///
+ /// The start point of the line.
+ /// The direction of the line.
+ /// The width and height of the box.
+ /// The first intersection point.
+ /// The second intersection point.
+ /// Whether the line definitely intersects the box.
+ private bool lineDefinitelyIntersectsBox(Vector2 lineStart, Vector2 lineDir, Vector2 box, out Vector2 p1, out Vector2 p2)
{
- var p2 = lineStart + lineDir;
+ p1 = Vector2.Zero;
+ p2 = Vector2.Zero;
- double d1 = det(Vector2.Zero);
- double d2 = det(new Vector2(box.X, 0));
- double d3 = det(new Vector2(0, box.Y));
- double d4 = det(box);
+ if (Precision.AlmostEquals(lineDir.X, 0))
+ {
+ // If the line is vertical, we only need to check if the X coordinate of the line is within the box.
+ if (!Precision.DefinitelyBigger(lineStart.X, 0) || !Precision.DefinitelyBigger(box.X, lineStart.X))
+ return false;
- return definitelyDifferentSign(d1, d2) || definitelyDifferentSign(d3, d4) ||
- definitelyDifferentSign(d1, d3) || definitelyDifferentSign(d2, d4);
+ p1 = new Vector2(lineStart.X, 0);
+ p2 = new Vector2(lineStart.X, box.Y);
+ return true;
+ }
- double det(Vector2 p) => (p.X - lineStart.X) * (p2.Y - lineStart.Y) - (p.Y - lineStart.Y) * (p2.X - lineStart.X);
+ if (Precision.AlmostEquals(lineDir.Y, 0))
+ {
+ // If the line is horizontal, we only need to check if the Y coordinate of the line is within the box.
+ if (!Precision.DefinitelyBigger(lineStart.Y, 0) || !Precision.DefinitelyBigger(box.Y, lineStart.Y))
+ return false;
- bool definitelyDifferentSign(double a, double b) => !Precision.AlmostEquals(a, 0) &&
- !Precision.AlmostEquals(b, 0) &&
- Math.Sign(a) != Math.Sign(b);
+ p1 = new Vector2(0, lineStart.Y);
+ p2 = new Vector2(box.X, lineStart.Y);
+ return true;
+ }
+
+ float m = lineDir.Y / lineDir.X;
+ float mInv = lineDir.X / lineDir.Y; // Use this to improve numerical stability if X is close to zero.
+ float b = lineStart.Y - m * lineStart.X;
+
+ // Calculate intersection points with the sides of the box.
+ var p = new List(4);
+
+ if (0 <= b && b <= box.Y)
+ p.Add(new Vector2(0, b));
+ if (0 <= (box.Y - b) * mInv && (box.Y - b) * mInv <= box.X)
+ p.Add(new Vector2((box.Y - b) * mInv, box.Y));
+ if (0 <= m * box.X + b && m * box.X + b <= box.Y)
+ p.Add(new Vector2(box.X, m * box.X + b));
+ if (0 <= -b * mInv && -b * mInv <= box.X)
+ p.Add(new Vector2(-b * mInv, 0));
+
+ switch (p.Count)
+ {
+ case 4:
+ // If there are 4 intersection points, the line is a diagonal of the box.
+ if (m > 0)
+ {
+ p1 = Vector2.Zero;
+ p2 = box;
+ }
+ else
+ {
+ p1 = new Vector2(0, box.Y);
+ p2 = new Vector2(box.X, 0);
+ }
+
+ break;
+
+ case 3:
+ // If there are 3 intersection points, the line goes through a corner of the box.
+ if (p[0] == p[1])
+ {
+ p1 = p[0];
+ p2 = p[2];
+ }
+ else
+ {
+ p1 = p[0];
+ p2 = p[1];
+ }
+
+ break;
+
+ case 2:
+ p1 = p[0];
+ p2 = p[1];
+
+ break;
+ }
+
+ return !Precision.AlmostEquals(p1, p2);
}
}
}
diff --git a/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs
index 36687ef73a..e576ac1e49 100644
--- a/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/PositionSnapGrid.cs
@@ -21,8 +21,6 @@ namespace osu.Game.Screens.Edit.Compose.Components
protected PositionSnapGrid()
{
- Masking = true;
-
StartPosition.BindValueChanged(_ => GridCache.Invalidate());
AddLayout(GridCache);
From b4b5cdfcf2d84527ec4d5cb9e504152be59b7e19 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Thu, 1 Feb 2024 17:07:03 +0100
Subject: [PATCH 065/924] Fix masking in circular snap grid
---
.../Edit/Compose/Components/CircularPositionSnapGrid.cs | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/osu.Game/Screens/Edit/Compose/Components/CircularPositionSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/CircularPositionSnapGrid.cs
index 403a270359..791cb33439 100644
--- a/osu.Game/Screens/Edit/Compose/Components/CircularPositionSnapGrid.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/CircularPositionSnapGrid.cs
@@ -82,7 +82,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
generatedCircles.First().Alpha = 0.8f;
- AddRangeInternal(generatedCircles);
+ AddInternal(new Container
+ {
+ Masking = true,
+ RelativeSizeAxes = Axes.Both,
+ Children = generatedCircles,
+ });
}
public override Vector2 GetSnappedPosition(Vector2 original)
From 93dbd7507fd61086a8c9d3422e6a02560254f4d4 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Thu, 1 Feb 2024 17:07:03 +0100
Subject: [PATCH 066/924] Fix masking in circular snap grid
---
.../Edit/Compose/Components/CircularPositionSnapGrid.cs | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/osu.Game/Screens/Edit/Compose/Components/CircularPositionSnapGrid.cs b/osu.Game/Screens/Edit/Compose/Components/CircularPositionSnapGrid.cs
index 403a270359..791cb33439 100644
--- a/osu.Game/Screens/Edit/Compose/Components/CircularPositionSnapGrid.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/CircularPositionSnapGrid.cs
@@ -82,7 +82,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
generatedCircles.First().Alpha = 0.8f;
- AddRangeInternal(generatedCircles);
+ AddInternal(new Container
+ {
+ Masking = true,
+ RelativeSizeAxes = Axes.Both,
+ Children = generatedCircles,
+ });
}
public override Vector2 GetSnappedPosition(Vector2 original)
From 8ccb14f19f1363c42eaf80718ed50c1a68338185 Mon Sep 17 00:00:00 2001
From: tsunyoku
Date: Tue, 6 Feb 2024 13:08:17 +0000
Subject: [PATCH 067/924] include slider count in accuracy pp if slider head
accuracy is in use
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 2 ++
1 file changed, 2 insertions(+)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index b31f4ff519..7f4c5f6c46 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -192,6 +192,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
// This percentage only considers HitCircles of any value - in this part of the calculation we focus on hitting the timing hit window.
double betterAccuracyPercentage;
int amountHitObjectsWithAccuracy = attributes.HitCircleCount;
+ if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
+ amountHitObjectsWithAccuracy += attributes.SliderCount;
if (amountHitObjectsWithAccuracy > 0)
betterAccuracyPercentage = ((countGreat - (totalHits - amountHitObjectsWithAccuracy)) * 6 + countOk * 2 + countMeh) / (double)(amountHitObjectsWithAccuracy * 6);
From 7d34542c12a8e1db707d101fc7988e32e9da74d8 Mon Sep 17 00:00:00 2001
From: TextAdventurer12
Date: Thu, 22 Feb 2024 15:14:56 +1300
Subject: [PATCH 068/924] use difficulty instead of topstrain
---
osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs | 7 ++++---
1 file changed, 4 insertions(+), 3 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index 918e702b45..13d89cf2b8 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -37,6 +37,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
protected virtual double DifficultyMultiplier => DEFAULT_DIFFICULTY_MULTIPLIER;
protected List objectStrains = new List();
+ protected double difficulty;
protected OsuStrainSkill(Mod[] mods)
: base(mods)
@@ -45,7 +46,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
public override double DifficultyValue()
{
- double difficulty = 0;
+ difficulty = 0;
double weight = 1;
// Sections with 0 strain are excluded to avoid worst-case time complexity of the following sort (e.g. /b/2351871).
@@ -78,9 +79,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
///
public double CountDifficultStrains()
{
- double topStrain = objectStrains.Max();
+ double consistentTopStrain = difficulty / 10; // What would the top strain be if all strain values were identical
- return objectStrains.Sum(s => Math.Pow(s / topStrain, 4));
+ return objectStrains.Sum(s => Math.Pow(1, s / consistentTopStrain, 5));
}
}
}
From 0db910deb90b792f41203ee9410ef6dc05231308 Mon Sep 17 00:00:00 2001
From: TextAdventurer12
Date: Thu, 22 Feb 2024 15:20:32 +1300
Subject: [PATCH 069/924] cap each note at adding 1 difficult strain count
---
osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index 13d89cf2b8..84bf8e3bf6 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -81,7 +81,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
{
double consistentTopStrain = difficulty / 10; // What would the top strain be if all strain values were identical
- return objectStrains.Sum(s => Math.Pow(1, s / consistentTopStrain, 5));
+ return objectStrains.Sum(s => Math.Pow(Math.Min(1, s / consistentTopStrain), 5));
}
}
}
From caba0510db86b66f9e238c640a7a09e272d67fdb Mon Sep 17 00:00:00 2001
From: nathen
Date: Sat, 9 Mar 2024 23:10:53 -0500
Subject: [PATCH 070/924] Compute the upper bound on deviation with a 99%
confidence interval
---
.../Difficulty/TaikoPerformanceCalculator.cs | 81 +++++++++----------
1 file changed, 40 insertions(+), 41 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 723a6612bc..322e3874ba 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
- estimatedUr = computeEstimatedUr(score, taikoAttributes);
+ estimatedUr = computeDeviationUpperBound(taikoAttributes) * 10;
// The effectiveMissCount is calculated by gaining a ratio for totalSuccessfulHits and increasing the miss penalty for shorter object counts lower than 1000.
if (totalSuccessfulHits > 0)
@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (attributes.GreatHitWindow <= 0 || estimatedUr == null)
return 0;
- double accuracyValue = Math.Pow(65 / estimatedUr.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
+ double accuracyValue = Math.Pow(70 / estimatedUr.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
@@ -115,10 +115,11 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
}
///
- /// Calculates the tap deviation for a player using the OD, object count, and scores of 300s, 100s, and misses, with an assumed mean hit error of 0.
- /// Consistency is ensured as identical SS scores on the same map and settings yield the same deviation.
+ /// Computes an upper bound on the player's tap deviation based on the OD, number of circles and sliders,
+ /// and the hit judgements, assuming the player's mean hit error is 0. The estimation is consistent in that
+ /// two SS scores on the same map with the same settings will always return the same deviation.
///
- private double? computeEstimatedUr(ScoreInfo score, TaikoDifficultyAttributes attributes)
+ private double? computeDeviationUpperBound(TaikoDifficultyAttributes attributes)
{
if (totalSuccessfulHits == 0 || attributes.GreatHitWindow <= 0)
return null;
@@ -126,53 +127,51 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
double h300 = attributes.GreatHitWindow;
double h100 = attributes.OkHitWindow;
- // Determines the probability of a deviation leading to the score's hit evaluations. The curve's apex represents the most probable deviation.
- double likelihoodGradient(double d)
+ const double z = 2.32634787404; // 99% critical value for the normal distribution (one-tailed).
+
+ // The upper bound on deviation, calculated with the ratio of 300s to 100s, and the great hit window.
+ double? calcDeviationGreatWindow()
{
- if (d <= 0)
- return 0;
+ if (countGreat == 0) return null;
- double p300 = logDiff(0, logPcHit(h300, d));
- double p100 = logDiff(logPcHit(h300, d), logPcHit(h100, d));
- double p0 = logPcHit(h100, d);
+ double n = totalSuccessfulHits;
- double gradient = Math.Exp(
- (countGreat * p300
- + (countOk + 0.5) * p100
- + countMiss * p0) / totalHits
- );
+ // Proportion of greats hit, ignoring misses.
+ double p = countGreat / n;
- return -gradient;
+ // We can be 99% confident that p is at least this value.
+ double pLowerBound = (n * p + z * z / 2) / (n + z * z) - z / (n + z * z) * Math.Sqrt(n * p * (1 - p) + z * z / 4);
+
+ // We can be 99% confident that the deviation is not higher than:
+ return h300 / (Math.Sqrt(2) * SpecialFunctions.ErfInv(pLowerBound));
}
- double deviation = FindMinimum.OfScalarFunction(likelihoodGradient, 30);
+ // The upper bound on deviation, calculated with the ratio of 300s + 100s to misses, and the good hit window.
+ // This will return a lower value than the first method when the number of 100s is high, but the miss count is low.
+ double? calcDeviationGoodWindow()
+ {
+ if (totalSuccessfulHits == 0) return null;
- return deviation * 10;
+ double n = totalHits;
+
+ // Proportion of greats + goods hit.
+ double p = totalSuccessfulHits / n;
+
+ // We can be 99% confident that p is at least this value.
+ double pLowerBound = (n * p + z * z / 2) / (n + z * z) - z / (n + z * z) * Math.Sqrt(n * p * (1 - p) + z * z / 4);
+
+ // We can be 99% confident that the deviation is not higher than:
+ return h100 / (Math.Sqrt(2) * SpecialFunctions.ErfInv(pLowerBound));
+ }
+
+ if (calcDeviationGreatWindow() is null)
+ return calcDeviationGoodWindow();
+
+ return Math.Min(calcDeviationGreatWindow()!.Value, calcDeviationGoodWindow()!.Value);
}
private int totalHits => countGreat + countOk + countMeh + countMiss;
private int totalSuccessfulHits => countGreat + countOk + countMeh;
-
- private double logPcHit(double x, double deviation) => logErfcApprox(x / (deviation * Math.Sqrt(2)));
-
- // Utilises a numerical approximation to extend the computation range of ln(erfc(x)).
- private double logErfcApprox(double x) => x <= 5
- ? Math.Log(SpecialFunctions.Erfc(x))
- : -Math.Pow(x, 2) - Math.Log(x * Math.Sqrt(Math.PI)); // https://www.desmos.com/calculator/kdbxwxgf01
-
- // Subtracts the base value of two logs, circumventing log rules that typically complicate subtraction of non-logarithmic values.
- private double logDiff(double firstLog, double secondLog)
- {
- double maxVal = Math.Max(firstLog, secondLog);
-
- // To avoid a NaN result, a check is performed to prevent subtraction of two negative infinity values.
- if (double.IsNegativeInfinity(maxVal))
- {
- return maxVal;
- }
-
- return firstLog + SpecialFunctions.Log1p(-Math.Exp(-(firstLog - secondLog)));
- }
}
}
From 6ddb2b7f8b1a40f3fc86892b00c67486884ac025 Mon Sep 17 00:00:00 2001
From: nathen
Date: Sun, 10 Mar 2024 00:19:04 -0500
Subject: [PATCH 071/924] Include misses in the great window deviation calc
---
.../Difficulty/TaikoPerformanceCalculator.cs | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 322e3874ba..8998b5cfa3 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -129,12 +129,12 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
const double z = 2.32634787404; // 99% critical value for the normal distribution (one-tailed).
- // The upper bound on deviation, calculated with the ratio of 300s to 100s, and the great hit window.
+ // The upper bound on deviation, calculated with the ratio of 300s to objects, and the great hit window.
double? calcDeviationGreatWindow()
{
if (countGreat == 0) return null;
- double n = totalSuccessfulHits;
+ double n = totalHits;
// Proportion of greats hit, ignoring misses.
double p = countGreat / n;
@@ -146,7 +146,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
return h300 / (Math.Sqrt(2) * SpecialFunctions.ErfInv(pLowerBound));
}
- // The upper bound on deviation, calculated with the ratio of 300s + 100s to misses, and the good hit window.
+ // The upper bound on deviation, calculated with the ratio of 300s + 100s to objects, and the good hit window.
// This will return a lower value than the first method when the number of 100s is high, but the miss count is low.
double? calcDeviationGoodWindow()
{
From 537059504aa12c4dbc4a790c8dc24603ccdd94f6 Mon Sep 17 00:00:00 2001
From: nathen
Date: Sun, 10 Mar 2024 00:20:06 -0500
Subject: [PATCH 072/924] Fix comment
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index 8998b5cfa3..c532d24f4d 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -136,7 +136,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
double n = totalHits;
- // Proportion of greats hit, ignoring misses.
+ // Proportion of greats hit.
double p = countGreat / n;
// We can be 99% confident that p is at least this value.
From a9b3416a3fe2e77f66c249c85636ca476ac3027c Mon Sep 17 00:00:00 2001
From: nathen
Date: Sun, 10 Mar 2024 00:37:28 -0500
Subject: [PATCH 073/924] Remove MathNet.Numerics dependency
---
.../Difficulty/TaikoPerformanceCalculator.cs | 2 +-
.../osu.Game.Rulesets.Taiko.csproj | 4 -
osu.Game/Utils/SpecialFunctions.cs | 694 ++++++++++++++++++
3 files changed, 695 insertions(+), 5 deletions(-)
create mode 100644 osu.Game/Utils/SpecialFunctions.cs
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index c532d24f4d..ca11397801 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Scoring;
using osu.Game.Rulesets.Taiko.Objects;
using osu.Game.Scoring;
-using MathNet.Numerics;
+using osu.Game.Utils;
namespace osu.Game.Rulesets.Taiko.Difficulty
{
diff --git a/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj b/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj
index 6ad5425d5b..cacba55c2a 100644
--- a/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj
+++ b/osu.Game.Rulesets.Taiko/osu.Game.Rulesets.Taiko.csproj
@@ -15,8 +15,4 @@
-
-
-
-
diff --git a/osu.Game/Utils/SpecialFunctions.cs b/osu.Game/Utils/SpecialFunctions.cs
new file mode 100644
index 0000000000..0b0f0598bb
--- /dev/null
+++ b/osu.Game/Utils/SpecialFunctions.cs
@@ -0,0 +1,694 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+// All code is referenced from the following:
+// https://github.com/mathnet/mathnet-numerics/blob/master/src/Numerics/SpecialFunctions/Erf.cs
+// https://github.com/mathnet/mathnet-numerics/blob/master/src/Numerics/Optimization/NelderMeadSimplex.cs
+
+/*
+ Copyright (c) 2002-2022 Math.NET
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+using System;
+
+namespace osu.Game.Utils
+{
+ public class SpecialFunctions
+ {
+ private const double sqrt2_pi = 2.5066282746310005024157652848110452530069867406099d;
+
+ ///
+ /// **************************************
+ /// COEFFICIENTS FOR METHOD ErfImp *
+ /// **************************************
+ ///
+ /// Polynomial coefficients for a numerator of ErfImp
+ /// calculation for Erf(x) in the interval [1e-10, 0.5].
+ ///
+ private static readonly double[] erf_imp_an = { 0.00337916709551257388990745, -0.00073695653048167948530905, -0.374732337392919607868241, 0.0817442448733587196071743, -0.0421089319936548595203468, 0.0070165709512095756344528, -0.00495091255982435110337458, 0.000871646599037922480317225 };
+
+ /// Polynomial coefficients for a denominator of ErfImp
+ /// calculation for Erf(x) in the interval [1e-10, 0.5].
+ ///
+ private static readonly double[] erf_imp_ad = { 1, -0.218088218087924645390535, 0.412542972725442099083918, -0.0841891147873106755410271, 0.0655338856400241519690695, -0.0120019604454941768171266, 0.00408165558926174048329689, -0.000615900721557769691924509 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [0.5, 0.75].
+ ///
+ private static readonly double[] erf_imp_bn = { -0.0361790390718262471360258, 0.292251883444882683221149, 0.281447041797604512774415, 0.125610208862766947294894, 0.0274135028268930549240776, 0.00250839672168065762786937 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [0.5, 0.75].
+ ///
+ private static readonly double[] erf_imp_bd = { 1, 1.8545005897903486499845, 1.43575803037831418074962, 0.582827658753036572454135, 0.124810476932949746447682, 0.0113724176546353285778481 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [0.75, 1.25].
+ ///
+ private static readonly double[] erf_imp_cn = { -0.0397876892611136856954425, 0.153165212467878293257683, 0.191260295600936245503129, 0.10276327061989304213645, 0.029637090615738836726027, 0.0046093486780275489468812, 0.000307607820348680180548455 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [0.75, 1.25].
+ ///
+ private static readonly double[] erf_imp_cd = { 1, 1.95520072987627704987886, 1.64762317199384860109595, 0.768238607022126250082483, 0.209793185936509782784315, 0.0319569316899913392596356, 0.00213363160895785378615014 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [1.25, 2.25].
+ ///
+ private static readonly double[] erf_imp_dn = { -0.0300838560557949717328341, 0.0538578829844454508530552, 0.0726211541651914182692959, 0.0367628469888049348429018, 0.00964629015572527529605267, 0.00133453480075291076745275, 0.778087599782504251917881e-4 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [1.25, 2.25].
+ ///
+ private static readonly double[] erf_imp_dd = { 1, 1.75967098147167528287343, 1.32883571437961120556307, 0.552528596508757581287907, 0.133793056941332861912279, 0.0179509645176280768640766, 0.00104712440019937356634038, -0.106640381820357337177643e-7 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [2.25, 3.5].
+ ///
+ private static readonly double[] erf_imp_en = { -0.0117907570137227847827732, 0.014262132090538809896674, 0.0202234435902960820020765, 0.00930668299990432009042239, 0.00213357802422065994322516, 0.00025022987386460102395382, 0.120534912219588189822126e-4 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [2.25, 3.5].
+ ///
+ private static readonly double[] erf_imp_ed = { 1, 1.50376225203620482047419, 0.965397786204462896346934, 0.339265230476796681555511, 0.0689740649541569716897427, 0.00771060262491768307365526, 0.000371421101531069302990367 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [3.5, 5.25].
+ ///
+ private static readonly double[] erf_imp_fn = { -0.00546954795538729307482955, 0.00404190278731707110245394, 0.0054963369553161170521356, 0.00212616472603945399437862, 0.000394984014495083900689956, 0.365565477064442377259271e-4, 0.135485897109932323253786e-5 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [3.5, 5.25].
+ ///
+ private static readonly double[] erf_imp_fd = { 1, 1.21019697773630784832251, 0.620914668221143886601045, 0.173038430661142762569515, 0.0276550813773432047594539, 0.00240625974424309709745382, 0.891811817251336577241006e-4, -0.465528836283382684461025e-11 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [5.25, 8].
+ ///
+ private static readonly double[] erf_imp_gn = { -0.00270722535905778347999196, 0.0013187563425029400461378, 0.00119925933261002333923989, 0.00027849619811344664248235, 0.267822988218331849989363e-4, 0.923043672315028197865066e-6 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [5.25, 8].
+ ///
+ private static readonly double[] erf_imp_gd = { 1, 0.814632808543141591118279, 0.268901665856299542168425, 0.0449877216103041118694989, 0.00381759663320248459168994, 0.000131571897888596914350697, 0.404815359675764138445257e-11 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [8, 11.5].
+ ///
+ private static readonly double[] erf_imp_hn = { -0.00109946720691742196814323, 0.000406425442750422675169153, 0.000274499489416900707787024, 0.465293770646659383436343e-4, 0.320955425395767463401993e-5, 0.778286018145020892261936e-7 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [8, 11.5].
+ ///
+ private static readonly double[] erf_imp_hd = { 1, 0.588173710611846046373373, 0.139363331289409746077541, 0.0166329340417083678763028, 0.00100023921310234908642639, 0.24254837521587225125068e-4 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [11.5, 17].
+ ///
+ private static readonly double[] erf_imp_in = { -0.00056907993601094962855594, 0.000169498540373762264416984, 0.518472354581100890120501e-4, 0.382819312231928859704678e-5, 0.824989931281894431781794e-7 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [11.5, 17].
+ ///
+ private static readonly double[] erf_imp_id = { 1, 0.339637250051139347430323, 0.043472647870310663055044, 0.00248549335224637114641629, 0.535633305337152900549536e-4, -0.117490944405459578783846e-12 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [17, 24].
+ ///
+ private static readonly double[] erf_imp_jn = { -0.000241313599483991337479091, 0.574224975202501512365975e-4, 0.115998962927383778460557e-4, 0.581762134402593739370875e-6, 0.853971555085673614607418e-8 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [17, 24].
+ ///
+ private static readonly double[] erf_imp_jd = { 1, 0.233044138299687841018015, 0.0204186940546440312625597, 0.000797185647564398289151125, 0.117019281670172327758019e-4 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [24, 38].
+ ///
+ private static readonly double[] erf_imp_kn = { -0.000146674699277760365803642, 0.162666552112280519955647e-4, 0.269116248509165239294897e-5, 0.979584479468091935086972e-7, 0.101994647625723465722285e-8 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [24, 38].
+ ///
+ private static readonly double[] erf_imp_kd = { 1, 0.165907812944847226546036, 0.0103361716191505884359634, 0.000286593026373868366935721, 0.298401570840900340874568e-5 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [38, 60].
+ ///
+ private static readonly double[] erf_imp_ln = { -0.583905797629771786720406e-4, 0.412510325105496173512992e-5, 0.431790922420250949096906e-6, 0.993365155590013193345569e-8, 0.653480510020104699270084e-10 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [38, 60].
+ ///
+ private static readonly double[] erf_imp_ld = { 1, 0.105077086072039915406159, 0.00414278428675475620830226, 0.726338754644523769144108e-4, 0.477818471047398785369849e-6 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [60, 85].
+ ///
+ private static readonly double[] erf_imp_mn = { -0.196457797609229579459841e-4, 0.157243887666800692441195e-5, 0.543902511192700878690335e-7, 0.317472492369117710852685e-9 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [60, 85].
+ ///
+ private static readonly double[] erf_imp_md = { 1, 0.052803989240957632204885, 0.000926876069151753290378112, 0.541011723226630257077328e-5, 0.535093845803642394908747e-15 };
+
+ /// Polynomial coefficients for a numerator in ErfImp
+ /// calculation for Erfc(x) in the interval [85, 110].
+ ///
+ private static readonly double[] erf_imp_nn = { -0.789224703978722689089794e-5, 0.622088451660986955124162e-6, 0.145728445676882396797184e-7, 0.603715505542715364529243e-10 };
+
+ /// Polynomial coefficients for a denominator in ErfImp
+ /// calculation for Erfc(x) in the interval [85, 110].
+ ///
+ private static readonly double[] erf_imp_nd = { 1, 0.0375328846356293715248719, 0.000467919535974625308126054, 0.193847039275845656900547e-5 };
+
+ ///
+ /// **************************************
+ /// COEFFICIENTS FOR METHOD ErfInvImp *
+ /// **************************************
+ ///
+ /// Polynomial coefficients for a numerator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0, 0.5].
+ ///
+ private static readonly double[] erv_inv_imp_an = { -0.000508781949658280665617, -0.00836874819741736770379, 0.0334806625409744615033, -0.0126926147662974029034, -0.0365637971411762664006, 0.0219878681111168899165, 0.00822687874676915743155, -0.00538772965071242932965 };
+
+ /// Polynomial coefficients for a denominator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0, 0.5].
+ ///
+ private static readonly double[] erv_inv_imp_ad = { 1, -0.970005043303290640362, -1.56574558234175846809, 1.56221558398423026363, 0.662328840472002992063, -0.71228902341542847553, -0.0527396382340099713954, 0.0795283687341571680018, -0.00233393759374190016776, 0.000886216390456424707504 };
+
+ /// Polynomial coefficients for a numerator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.5, 0.75].
+ ///
+ private static readonly double[] erv_inv_imp_bn = { -0.202433508355938759655, 0.105264680699391713268, 8.37050328343119927838, 17.6447298408374015486, -18.8510648058714251895, -44.6382324441786960818, 17.445385985570866523, 21.1294655448340526258, -3.67192254707729348546 };
+
+ /// Polynomial coefficients for a denominator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.5, 0.75].
+ ///
+ private static readonly double[] erv_inv_imp_bd = { 1, 6.24264124854247537712, 3.9713437953343869095, -28.6608180499800029974, -20.1432634680485188801, 48.5609213108739935468, 10.8268667355460159008, -22.6436933413139721736, 1.72114765761200282724 };
+
+ /// Polynomial coefficients for a numerator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.75, 1] with x less than 3.
+ ///
+ private static readonly double[] erv_inv_imp_cn = { -0.131102781679951906451, -0.163794047193317060787, 0.117030156341995252019, 0.387079738972604337464, 0.337785538912035898924, 0.142869534408157156766, 0.0290157910005329060432, 0.00214558995388805277169, -0.679465575181126350155e-6, 0.285225331782217055858e-7, -0.681149956853776992068e-9 };
+
+ /// Polynomial coefficients for a denominator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.75, 1] with x less than 3.
+ ///
+ private static readonly double[] erv_inv_imp_cd = { 1, 3.46625407242567245975, 5.38168345707006855425, 4.77846592945843778382, 2.59301921623620271374, 0.848854343457902036425, 0.152264338295331783612, 0.01105924229346489121 };
+
+ /// Polynomial coefficients for a numerator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.75, 1] with x between 3 and 6.
+ ///
+ private static readonly double[] erv_inv_imp_dn = { -0.0350353787183177984712, -0.00222426529213447927281, 0.0185573306514231072324, 0.00950804701325919603619, 0.00187123492819559223345, 0.000157544617424960554631, 0.460469890584317994083e-5, -0.230404776911882601748e-9, 0.266339227425782031962e-11 };
+
+ /// Polynomial coefficients for a denominator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.75, 1] with x between 3 and 6.
+ ///
+ private static readonly double[] erv_inv_imp_dd = { 1, 1.3653349817554063097, 0.762059164553623404043, 0.220091105764131249824, 0.0341589143670947727934, 0.00263861676657015992959, 0.764675292302794483503e-4 };
+
+ /// Polynomial coefficients for a numerator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.75, 1] with x between 6 and 18.
+ ///
+ private static readonly double[] erv_inv_imp_en = { -0.0167431005076633737133, -0.00112951438745580278863, 0.00105628862152492910091, 0.000209386317487588078668, 0.149624783758342370182e-4, 0.449696789927706453732e-6, 0.462596163522878599135e-8, -0.281128735628831791805e-13, 0.99055709973310326855e-16 };
+
+ /// Polynomial coefficients for a denominator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.75, 1] with x between 6 and 18.
+ ///
+ private static readonly double[] erv_inv_imp_ed = { 1, 0.591429344886417493481, 0.138151865749083321638, 0.0160746087093676504695, 0.000964011807005165528527, 0.275335474764726041141e-4, 0.282243172016108031869e-6 };
+
+ /// Polynomial coefficients for a numerator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.75, 1] with x between 18 and 44.
+ ///
+ private static readonly double[] erv_inv_imp_fn = { -0.0024978212791898131227, -0.779190719229053954292e-5, 0.254723037413027451751e-4, 0.162397777342510920873e-5, 0.396341011304801168516e-7, 0.411632831190944208473e-9, 0.145596286718675035587e-11, -0.116765012397184275695e-17 };
+
+ /// Polynomial coefficients for a denominator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.75, 1] with x between 18 and 44.
+ ///
+ private static readonly double[] erv_inv_imp_fd = { 1, 0.207123112214422517181, 0.0169410838120975906478, 0.000690538265622684595676, 0.145007359818232637924e-4, 0.144437756628144157666e-6, 0.509761276599778486139e-9 };
+
+ /// Polynomial coefficients for a numerator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.75, 1] with x greater than 44.
+ ///
+ private static readonly double[] erv_inv_imp_gn = { -0.000539042911019078575891, -0.28398759004727721098e-6, 0.899465114892291446442e-6, 0.229345859265920864296e-7, 0.225561444863500149219e-9, 0.947846627503022684216e-12, 0.135880130108924861008e-14, -0.348890393399948882918e-21 };
+
+ /// Polynomial coefficients for a denominator of ErfInvImp
+ /// calculation for Erf^-1(z) in the interval [0.75, 1] with x greater than 44.
+ ///
+ private static readonly double[] erv_inv_imp_gd = { 1, 0.0845746234001899436914, 0.00282092984726264681981, 0.468292921940894236786e-4, 0.399968812193862100054e-6, 0.161809290887904476097e-8, 0.231558608310259605225e-11 };
+
+ /// Calculates the error function.
+ /// The value to evaluate.
+ /// the error function evaluated at given value.
+ ///
+ ///
+ /// - returns 1 if x == double.PositiveInfinity.
+ /// - returns -1 if x == double.NegativeInfinity.
+ ///
+ ///
+ public static double Erf(double x)
+ {
+ if (x == 0)
+ {
+ return 0;
+ }
+
+ if (double.IsPositiveInfinity(x))
+ {
+ return 1;
+ }
+
+ if (double.IsNegativeInfinity(x))
+ {
+ return -1;
+ }
+
+ if (double.IsNaN(x))
+ {
+ return double.NaN;
+ }
+
+ return erfImp(x, false);
+ }
+
+ /// Calculates the complementary error function.
+ /// The value to evaluate.
+ /// the complementary error function evaluated at given value.
+ ///
+ ///
+ /// - returns 0 if x == double.PositiveInfinity.
+ /// - returns 2 if x == double.NegativeInfinity.
+ ///
+ ///
+ public static double Erfc(double x)
+ {
+ if (x == 0)
+ {
+ return 1;
+ }
+
+ if (double.IsPositiveInfinity(x))
+ {
+ return 0;
+ }
+
+ if (double.IsNegativeInfinity(x))
+ {
+ return 2;
+ }
+
+ if (double.IsNaN(x))
+ {
+ return double.NaN;
+ }
+
+ return erfImp(x, true);
+ }
+
+ /// Calculates the inverse error function evaluated at z.
+ /// The inverse error function evaluated at given value.
+ ///
+ ///
+ /// - returns double.PositiveInfinity if z >= 1.0.
+ /// - returns double.NegativeInfinity if z <= -1.0.
+ ///
+ ///
+ /// Calculates the inverse error function evaluated at z.
+ /// value to evaluate.
+ /// the inverse error function evaluated at Z.
+ public static double ErfInv(double z)
+ {
+ if (z == 0.0)
+ {
+ return 0.0;
+ }
+
+ if (z >= 1.0)
+ {
+ return double.PositiveInfinity;
+ }
+
+ if (z <= -1.0)
+ {
+ return double.NegativeInfinity;
+ }
+
+ double p, q, s;
+
+ if (z < 0)
+ {
+ p = -z;
+ q = 1 - p;
+ s = -1;
+ }
+ else
+ {
+ p = z;
+ q = 1 - z;
+ s = 1;
+ }
+
+ return erfInvImpl(p, q, s);
+ }
+
+ ///
+ /// Implementation of the error function.
+ ///
+ /// Where to evaluate the error function.
+ /// Whether to compute 1 - the error function.
+ /// the error function.
+ private static double erfImp(double z, bool invert)
+ {
+ if (z < 0)
+ {
+ if (!invert)
+ {
+ return -erfImp(-z, false);
+ }
+
+ if (z < -0.5)
+ {
+ return 2 - erfImp(-z, true);
+ }
+
+ return 1 + erfImp(-z, false);
+ }
+
+ double result;
+
+ // Big bunch of selection statements now to pick which
+ // implementation to use, try to put most likely options
+ // first:
+ if (z < 0.5)
+ {
+ // We're going to calculate erf:
+ if (z < 1e-10)
+ {
+ result = (z * 1.125) + (z * 0.003379167095512573896158903121545171688);
+ }
+ else
+ {
+ // Worst case absolute error found: 6.688618532e-21
+ result = (z * 1.125) + (z * evaluatePolynomial(z, erf_imp_an) / evaluatePolynomial(z, erf_imp_ad));
+ }
+ }
+ else if (z < 110)
+ {
+ // We'll be calculating erfc:
+ invert = !invert;
+ double r, b;
+
+ if (z < 0.75)
+ {
+ // Worst case absolute error found: 5.582813374e-21
+ r = evaluatePolynomial(z - 0.5, erf_imp_bn) / evaluatePolynomial(z - 0.5, erf_imp_bd);
+ b = 0.3440242112F;
+ }
+ else if (z < 1.25)
+ {
+ // Worst case absolute error found: 4.01854729e-21
+ r = evaluatePolynomial(z - 0.75, erf_imp_cn) / evaluatePolynomial(z - 0.75, erf_imp_cd);
+ b = 0.419990927F;
+ }
+ else if (z < 2.25)
+ {
+ // Worst case absolute error found: 2.866005373e-21
+ r = evaluatePolynomial(z - 1.25, erf_imp_dn) / evaluatePolynomial(z - 1.25, erf_imp_dd);
+ b = 0.4898625016F;
+ }
+ else if (z < 3.5)
+ {
+ // Worst case absolute error found: 1.045355789e-21
+ r = evaluatePolynomial(z - 2.25, erf_imp_en) / evaluatePolynomial(z - 2.25, erf_imp_ed);
+ b = 0.5317370892F;
+ }
+ else if (z < 5.25)
+ {
+ // Worst case absolute error found: 8.300028706e-22
+ r = evaluatePolynomial(z - 3.5, erf_imp_fn) / evaluatePolynomial(z - 3.5, erf_imp_fd);
+ b = 0.5489973426F;
+ }
+ else if (z < 8)
+ {
+ // Worst case absolute error found: 1.700157534e-21
+ r = evaluatePolynomial(z - 5.25, erf_imp_gn) / evaluatePolynomial(z - 5.25, erf_imp_gd);
+ b = 0.5571740866F;
+ }
+ else if (z < 11.5)
+ {
+ // Worst case absolute error found: 3.002278011e-22
+ r = evaluatePolynomial(z - 8, erf_imp_hn) / evaluatePolynomial(z - 8, erf_imp_hd);
+ b = 0.5609807968F;
+ }
+ else if (z < 17)
+ {
+ // Worst case absolute error found: 6.741114695e-21
+ r = evaluatePolynomial(z - 11.5, erf_imp_in) / evaluatePolynomial(z - 11.5, erf_imp_id);
+ b = 0.5626493692F;
+ }
+ else if (z < 24)
+ {
+ // Worst case absolute error found: 7.802346984e-22
+ r = evaluatePolynomial(z - 17, erf_imp_jn) / evaluatePolynomial(z - 17, erf_imp_jd);
+ b = 0.5634598136F;
+ }
+ else if (z < 38)
+ {
+ // Worst case absolute error found: 2.414228989e-22
+ r = evaluatePolynomial(z - 24, erf_imp_kn) / evaluatePolynomial(z - 24, erf_imp_kd);
+ b = 0.5638477802F;
+ }
+ else if (z < 60)
+ {
+ // Worst case absolute error found: 5.896543869e-24
+ r = evaluatePolynomial(z - 38, erf_imp_ln) / evaluatePolynomial(z - 38, erf_imp_ld);
+ b = 0.5640528202F;
+ }
+ else if (z < 85)
+ {
+ // Worst case absolute error found: 3.080612264e-21
+ r = evaluatePolynomial(z - 60, erf_imp_mn) / evaluatePolynomial(z - 60, erf_imp_md);
+ b = 0.5641309023F;
+ }
+ else
+ {
+ // Worst case absolute error found: 8.094633491e-22
+ r = evaluatePolynomial(z - 85, erf_imp_nn) / evaluatePolynomial(z - 85, erf_imp_nd);
+ b = 0.5641584396F;
+ }
+
+ double g = Math.Exp(-z * z) / z;
+ result = (g * b) + (g * r);
+ }
+ else
+ {
+ // Any value of z larger than 28 will underflow to zero:
+ result = 0;
+ invert = !invert;
+ }
+
+ if (invert)
+ {
+ result = 1 - result;
+ }
+
+ return result;
+ }
+
+ /// Calculates the complementary inverse error function evaluated at z.
+ /// The complementary inverse error function evaluated at given value.
+ /// We have tested this implementation against the arbitrary precision mpmath library
+ /// and found cases where we can only guarantee 9 significant figures correct.
+ ///
+ /// - returns double.PositiveInfinity if z <= 0.0.
+ /// - returns double.NegativeInfinity if z >= 2.0.
+ ///
+ ///
+ /// calculates the complementary inverse error function evaluated at z.
+ /// value to evaluate.
+ /// the complementary inverse error function evaluated at Z.
+ public static double ErfcInv(double z)
+ {
+ if (z <= 0.0)
+ {
+ return double.PositiveInfinity;
+ }
+
+ if (z >= 2.0)
+ {
+ return double.NegativeInfinity;
+ }
+
+ double p, q, s;
+
+ if (z > 1)
+ {
+ q = 2 - z;
+ p = 1 - q;
+ s = -1;
+ }
+ else
+ {
+ p = 1 - z;
+ q = z;
+ s = 1;
+ }
+
+ return erfInvImpl(p, q, s);
+ }
+
+ ///
+ /// The implementation of the inverse error function.
+ ///
+ /// First intermediate parameter.
+ /// Second intermediate parameter.
+ /// Third intermediate parameter.
+ /// the inverse error function.
+ private static double erfInvImpl(double p, double q, double s)
+ {
+ double result;
+
+ if (p <= 0.5)
+ {
+ // Evaluate inverse erf using the rational approximation:
+ //
+ // x = p(p+10)(Y+R(p))
+ //
+ // Where Y is a constant, and R(p) is optimized for a low
+ // absolute error compared to |Y|.
+ //
+ // double: Max error found: 2.001849e-18
+ // long double: Max error found: 1.017064e-20
+ // Maximum Deviation Found (actual error term at infinite precision) 8.030e-21
+ const float y = 0.0891314744949340820313f;
+ double g = p * (p + 10);
+ double r = evaluatePolynomial(p, erv_inv_imp_an) / evaluatePolynomial(p, erv_inv_imp_ad);
+ result = (g * y) + (g * r);
+ }
+ else if (q >= 0.25)
+ {
+ // Rational approximation for 0.5 > q >= 0.25
+ //
+ // x = sqrt(-2*log(q)) / (Y + R(q))
+ //
+ // Where Y is a constant, and R(q) is optimized for a low
+ // absolute error compared to Y.
+ //
+ // double : Max error found: 7.403372e-17
+ // long double : Max error found: 6.084616e-20
+ // Maximum Deviation Found (error term) 4.811e-20
+ const float y = 2.249481201171875f;
+ double g = Math.Sqrt(-2 * Math.Log(q));
+ double xs = q - 0.25;
+ double r = evaluatePolynomial(xs, erv_inv_imp_bn) / evaluatePolynomial(xs, erv_inv_imp_bd);
+ result = g / (y + r);
+ }
+ else
+ {
+ // For q < 0.25 we have a series of rational approximations all
+ // of the general form:
+ //
+ // let: x = sqrt(-log(q))
+ //
+ // Then the result is given by:
+ //
+ // x(Y+R(x-B))
+ //
+ // where Y is a constant, B is the lowest value of x for which
+ // the approximation is valid, and R(x-B) is optimized for a low
+ // absolute error compared to Y.
+ //
+ // Note that almost all code will really go through the first
+ // or maybe second approximation. After than we're dealing with very
+ // small input values indeed: 80 and 128 bit long double's go all the
+ // way down to ~ 1e-5000 so the "tail" is rather long...
+ double x = Math.Sqrt(-Math.Log(q));
+
+ if (x < 3)
+ {
+ // Max error found: 1.089051e-20
+ const float y = 0.807220458984375f;
+ double xs = x - 1.125;
+ double r = evaluatePolynomial(xs, erv_inv_imp_cn) / evaluatePolynomial(xs, erv_inv_imp_cd);
+ result = (y * x) + (r * x);
+ }
+ else if (x < 6)
+ {
+ // Max error found: 8.389174e-21
+ const float y = 0.93995571136474609375f;
+ double xs = x - 3;
+ double r = evaluatePolynomial(xs, erv_inv_imp_dn) / evaluatePolynomial(xs, erv_inv_imp_dd);
+ result = (y * x) + (r * x);
+ }
+ else if (x < 18)
+ {
+ // Max error found: 1.481312e-19
+ const float y = 0.98362827301025390625f;
+ double xs = x - 6;
+ double r = evaluatePolynomial(xs, erv_inv_imp_en) / evaluatePolynomial(xs, erv_inv_imp_ed);
+ result = (y * x) + (r * x);
+ }
+ else if (x < 44)
+ {
+ // Max error found: 5.697761e-20
+ const float y = 0.99714565277099609375f;
+ double xs = x - 18;
+ double r = evaluatePolynomial(xs, erv_inv_imp_fn) / evaluatePolynomial(xs, erv_inv_imp_fd);
+ result = (y * x) + (r * x);
+ }
+ else
+ {
+ // Max error found: 1.279746e-20
+ const float y = 0.99941349029541015625f;
+ double xs = x - 44;
+ double r = evaluatePolynomial(xs, erv_inv_imp_gn) / evaluatePolynomial(xs, erv_inv_imp_gd);
+ result = (y * x) + (r * x);
+ }
+ }
+
+ return s * result;
+ }
+
+ ///
+ /// Evaluate a polynomial at point x.
+ /// Coefficients are ordered ascending by power with power k at index k.
+ /// Example: coefficients [3,-1,2] represent y=2x^2-x+3.
+ ///
+ /// The location where to evaluate the polynomial at.
+ /// The coefficients of the polynomial, coefficient for power k at index k.
+ ///
+ /// is a null reference.
+ ///
+ private static double evaluatePolynomial(double z, params double[] coefficients)
+ {
+ // 2020-10-07 jbialogrodzki #730 Since this is public API we should probably
+ // handle null arguments? It doesn't seem to have been done consistently in this class though.
+ if (coefficients == null)
+ {
+ throw new ArgumentNullException(nameof(coefficients));
+ }
+
+ // 2020-10-07 jbialogrodzki #730 Zero polynomials need explicit handling.
+ // Without this check, we attempted to peek coefficients at negative indices!
+ int n = coefficients.Length;
+
+ if (n == 0)
+ {
+ return 0;
+ }
+
+ double sum = coefficients[n - 1];
+
+ for (int i = n - 2; i >= 0; --i)
+ {
+ sum *= z;
+ sum += coefficients[i];
+ }
+
+ return sum;
+ }
+ }
+}
From 941c0487a454fad1447812f2cd12fad26f1cd28c Mon Sep 17 00:00:00 2001
From: Fina
Date: Thu, 21 Mar 2024 19:02:36 -0700
Subject: [PATCH 074/924] Make length bonus account for sliders, use proper
misscount for classic
---
.../Difficulty/OsuPerformanceCalculator.cs | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index b31f4ff519..fa5bd8e094 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -23,6 +23,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
private int countMiss;
private double effectiveMissCount;
+ private bool SLIDERS_ACC;
public OsuPerformanceCalculator()
: base(new OsuRuleset())
@@ -33,13 +34,15 @@ namespace osu.Game.Rulesets.Osu.Difficulty
{
var osuAttributes = (OsuDifficultyAttributes)attributes;
+ SLIDERS_ACC = !score.Mods.Any(m => m is OsuModClassic);
+
accuracy = score.Accuracy;
scoreMaxCombo = score.MaxCombo;
countGreat = score.Statistics.GetValueOrDefault(HitResult.Great);
countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
- effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
+ effectiveMissCount = SLIDERS_ACC ? countMiss : calculateEffectiveMissCount(osuAttributes);
double multiplier = PERFORMANCE_BASE_MULTIPLIER;
@@ -191,7 +194,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
// This percentage only considers HitCircles of any value - in this part of the calculation we focus on hitting the timing hit window.
double betterAccuracyPercentage;
- int amountHitObjectsWithAccuracy = attributes.HitCircleCount;
+ int amountHitObjectsWithAccuracy = SLIDERS_ACC ? attributes.HitCircleCount + attributes.SliderCount : attributes.HitCircleCount;
if (amountHitObjectsWithAccuracy > 0)
betterAccuracyPercentage = ((countGreat - (totalHits - amountHitObjectsWithAccuracy)) * 6 + countOk * 2 + countMeh) / (double)(amountHitObjectsWithAccuracy * 6);
From 4db6f288d3cad1d848d76e11a9f31941169b800d Mon Sep 17 00:00:00 2001
From: Fina
Date: Thu, 21 Mar 2024 23:15:36 -0700
Subject: [PATCH 075/924] Use actual sliderends dropped instead of estimating
Score data for non-CL scores includes sliderends dropped, meaning no need to estimate.
CL scores are still estimated.
---
.../Difficulty/OsuPerformanceCalculator.cs | 8 +++++++-
1 file changed, 7 insertions(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index b31f4ff519..1e90df3081 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -21,6 +21,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
private int countOk;
private int countMeh;
private int countMiss;
+ private int countSliderEndsDropped;
private double effectiveMissCount;
@@ -39,6 +40,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
+ countSliderEndsDropped = score.Statistics.GetValueOrDefault(HitResult.SmallTickMiss);
effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
double multiplier = PERFORMANCE_BASE_MULTIPLIER;
@@ -123,7 +125,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (attributes.SliderCount > 0)
{
double estimateSliderEndsDropped = Math.Clamp(Math.Min(countOk + countMeh + countMiss, attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
- double sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - estimateSliderEndsDropped / estimateDifficultSliders, 3) + attributes.SliderFactor;
+ double sliderNerfFactor = 0;
+ if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
+ sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - countSliderEndsDropped / estimateDifficultSliders, 3) + attributes.SliderFactor;
+ else
+ sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - estimateSliderEndsDropped / estimateDifficultSliders, 3) + attributes.SliderFactor;
aimValue *= sliderNerfFactor;
}
From 3dafdc01bb006b36f1ecea460efa2dd8587f1333 Mon Sep 17 00:00:00 2001
From: Fina
Date: Thu, 21 Mar 2024 23:17:10 -0700
Subject: [PATCH 076/924] Revert "Make length bonus account for sliders, use
proper misscount for classic"
This reverts commit 941c0487a454fad1447812f2cd12fad26f1cd28c.
---
.../Difficulty/OsuPerformanceCalculator.cs | 7 ++-----
1 file changed, 2 insertions(+), 5 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index fa5bd8e094..b31f4ff519 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -23,7 +23,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
private int countMiss;
private double effectiveMissCount;
- private bool SLIDERS_ACC;
public OsuPerformanceCalculator()
: base(new OsuRuleset())
@@ -34,15 +33,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty
{
var osuAttributes = (OsuDifficultyAttributes)attributes;
- SLIDERS_ACC = !score.Mods.Any(m => m is OsuModClassic);
-
accuracy = score.Accuracy;
scoreMaxCombo = score.MaxCombo;
countGreat = score.Statistics.GetValueOrDefault(HitResult.Great);
countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
- effectiveMissCount = SLIDERS_ACC ? countMiss : calculateEffectiveMissCount(osuAttributes);
+ effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
double multiplier = PERFORMANCE_BASE_MULTIPLIER;
@@ -194,7 +191,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
// This percentage only considers HitCircles of any value - in this part of the calculation we focus on hitting the timing hit window.
double betterAccuracyPercentage;
- int amountHitObjectsWithAccuracy = SLIDERS_ACC ? attributes.HitCircleCount + attributes.SliderCount : attributes.HitCircleCount;
+ int amountHitObjectsWithAccuracy = attributes.HitCircleCount;
if (amountHitObjectsWithAccuracy > 0)
betterAccuracyPercentage = ((countGreat - (totalHits - amountHitObjectsWithAccuracy)) * 6 + countOk * 2 + countMeh) / (double)(amountHitObjectsWithAccuracy * 6);
From 840845527f68adab6fe0a2f3e28d0ad3af8d863d Mon Sep 17 00:00:00 2001
From: Fina
Date: Thu, 21 Mar 2024 23:24:37 -0700
Subject: [PATCH 077/924] Use miss count for effective miss count
No need to estimate misses for non-CL scores.
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index b31f4ff519..e000438e5f 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -39,7 +39,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
- effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
+ if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
+ effectiveMissCount = countMiss;
+ else
+ effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
double multiplier = PERFORMANCE_BASE_MULTIPLIER;
From b0d20e68ae303076d4dc644f32af8e98cb62cf98 Mon Sep 17 00:00:00 2001
From: Fina
Date: Thu, 21 Mar 2024 23:31:45 -0700
Subject: [PATCH 078/924] Update OsuPerformanceCalculator.cs
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 08a09f3929..8fbee5931d 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
countSliderEndsDropped = score.Statistics.GetValueOrDefault(HitResult.SmallTickMiss);
-
+
if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
effectiveMissCount = countMiss;
else
From 6fe478c8655a2da8979f04e3278b65ea24f58f02 Mon Sep 17 00:00:00 2001
From: Fina
Date: Thu, 21 Mar 2024 23:49:54 -0700
Subject: [PATCH 079/924] Add slider ticks and reverse arrows to effective
misscount
Very much open to discussion on if these should be weighed differently
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 8fbee5931d..94548e4985 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -21,6 +21,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
private int countOk;
private int countMeh;
private int countMiss;
+ private int countLargeTickMiss;
private int countSliderEndsDropped;
private double effectiveMissCount;
@@ -40,10 +41,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
+ countLargeTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
countSliderEndsDropped = score.Statistics.GetValueOrDefault(HitResult.SmallTickMiss);
-
if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
- effectiveMissCount = countMiss;
+ effectiveMissCount = countMiss + countLargeTickMiss;
else
effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
From 58bc184e0a266ddef4269e89030d96e2e42f38a2 Mon Sep 17 00:00:00 2001
From: Fina
Date: Sat, 23 Mar 2024 14:43:26 -0700
Subject: [PATCH 080/924] Use sliderend data for all non-legacy scores
As per suggestion by givikap, I was not aware that non-legacy cl scores stored this data
---
.../Difficulty/OsuPerformanceCalculator.cs | 12 +++++++-----
1 file changed, 7 insertions(+), 5 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 94548e4985..d6b7a17678 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -129,12 +129,14 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (attributes.SliderCount > 0)
{
- double estimateSliderEndsDropped = Math.Clamp(Math.Min(countOk + countMeh + countMiss, attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
- double sliderNerfFactor = 0;
- if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
- sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - countSliderEndsDropped / estimateDifficultSliders, 3) + attributes.SliderFactor;
+ double estimateSliderEndsDropped;
+ if (score.IsLegacyScore)
+ estimateSliderEndsDropped = Math.Clamp(Math.Min(countOk + countMeh + countMiss, attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
else
- sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - estimateSliderEndsDropped / estimateDifficultSliders, 3) + attributes.SliderFactor;
+ estimateSliderEndsDropped = countSliderEndsDropped;
+
+ double sliderNerfFactor = 0;
+ sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - estimateSliderEndsDropped / estimateDifficultSliders, 3) + attributes.SliderFactor;
aimValue *= sliderNerfFactor;
}
From 9f5f6b5d37405787a4308db875331060f54572b4 Mon Sep 17 00:00:00 2001
From: TextAdventurer12
Date: Sat, 6 Apr 2024 21:39:27 +1300
Subject: [PATCH 081/924] stop capping difficult strains per note
---
osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index 84bf8e3bf6..b585a30855 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -81,7 +81,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
{
double consistentTopStrain = difficulty / 10; // What would the top strain be if all strain values were identical
- return objectStrains.Sum(s => Math.Pow(Math.Min(1, s / consistentTopStrain), 5));
+ // Apply a power to nerf diffspikes, but only apply that power if s / adjustedDifficulty is less than 1, to prevent buffing certain spiky maps
+ return objectStrains.Sum(s => s >= adjustedDifficulty ? s / adjustedDifficulty : Math.Pow(s / adjustedDifficulty, 8));
}
}
-}
+}
\ No newline at end of file
From 2dd49036edaec714641d55475849fcf3f852c452 Mon Sep 17 00:00:00 2001
From: Fina <75299710+Finadoggie@users.noreply.github.com>
Date: Wed, 10 Apr 2024 20:31:52 -0700
Subject: [PATCH 082/924] Cap Buzz Slider Related Misses
After letting the comments @Flamiii left brew for a while, I realized they were very much right about the buzz slider thing. As such, I've implemented a quick and dirty untested fix that will hopefully have zero unintended side-effects :)
I don't see this as a permanent or final solution yet. There's definitely some potential issues/inaccuracies that could arise with maps like Notch Hell or IOException's Black Rover, but afaik this implementation would not cause any issues that stable doesn't already have.
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index d6b7a17678..0dd2adaec8 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -44,10 +44,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countLargeTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
countSliderEndsDropped = score.Statistics.GetValueOrDefault(HitResult.SmallTickMiss);
if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
- effectiveMissCount = countMiss + countLargeTickMiss;
+ effectiveMissCount = countMiss + Math.Min(countLargeTickMiss, calculateEffectiveMissCount(osuAttributes) - countMiss); // Cap stuff like buzz-slider related drops to a sane value
else
effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
+
double multiplier = PERFORMANCE_BASE_MULTIPLIER;
if (score.Mods.Any(m => m is OsuModNoFail))
From dd17c898b3037fb5be4996acf4e6a31639674812 Mon Sep 17 00:00:00 2001
From: Fina
Date: Thu, 11 Apr 2024 19:07:48 -0700
Subject: [PATCH 083/924] removed large tick misses from effectivemisscount
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 0dd2adaec8..830bc47731 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countLargeTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
countSliderEndsDropped = score.Statistics.GetValueOrDefault(HitResult.SmallTickMiss);
if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
- effectiveMissCount = countMiss + Math.Min(countLargeTickMiss, calculateEffectiveMissCount(osuAttributes) - countMiss); // Cap stuff like buzz-slider related drops to a sane value
+ effectiveMissCount = countMiss;
else
effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
From b32d73ec9b7be94b3f55a7007e236cffd9228ca1 Mon Sep 17 00:00:00 2001
From: TextAdventurer12
Date: Sat, 13 Apr 2024 02:43:33 +1200
Subject: [PATCH 084/924] adjust weighting function
---
osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs | 5 ++---
1 file changed, 2 insertions(+), 3 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index b585a30855..c20ea732ec 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -80,9 +80,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
public double CountDifficultStrains()
{
double consistentTopStrain = difficulty / 10; // What would the top strain be if all strain values were identical
-
- // Apply a power to nerf diffspikes, but only apply that power if s / adjustedDifficulty is less than 1, to prevent buffing certain spiky maps
- return objectStrains.Sum(s => s >= adjustedDifficulty ? s / adjustedDifficulty : Math.Pow(s / adjustedDifficulty, 8));
+ // Use a weighted sum of all strains. Constants are arbitrary and give nice values
+ return objectStrains.Sum(s => 1.3 / (1 + Math.Exp(-14.15 * (Math.Pow(s / consistentTopStrain, 2) - 0.945))));
}
}
}
\ No newline at end of file
From e2a5d1904b000965f009ee746a3175396011e3fc Mon Sep 17 00:00:00 2001
From: TextAdventurer12
Date: Wed, 17 Apr 2024 01:21:06 +1200
Subject: [PATCH 085/924] adjust count difficult strains formula
---
osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index c20ea732ec..beaf1d1288 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -81,7 +81,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
{
double consistentTopStrain = difficulty / 10; // What would the top strain be if all strain values were identical
// Use a weighted sum of all strains. Constants are arbitrary and give nice values
- return objectStrains.Sum(s => 1.3 / (1 + Math.Exp(-14.15 * (Math.Pow(s / consistentTopStrain, 2) - 0.945))));
+ return objectStrains.Sum(s => 1.1 / (1 + Math.Exp(-10 * (s / consistentTopStrain - 0.88))));
}
}
}
\ No newline at end of file
From ca246015d5c5e46ddbb6eaa003ae1d87a818aa7c Mon Sep 17 00:00:00 2001
From: Fina <75299710+Finadoggie@users.noreply.github.com>
Date: Fri, 19 Apr 2024 16:00:31 -0700
Subject: [PATCH 086/924] Add bool useSliderHead
---
.../Difficulty/OsuPerformanceCalculator.cs | 16 +++++++++++-----
1 file changed, 11 insertions(+), 5 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 830bc47731..c78fae1c79 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -15,6 +15,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
{
public const double PERFORMANCE_BASE_MULTIPLIER = 1.14; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things.
+ private bool useSliderHead;
+
private double accuracy;
private int scoreMaxCombo;
private int countGreat;
@@ -35,6 +37,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
{
var osuAttributes = (OsuDifficultyAttributes)attributes;
+ useSliderHead = !score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value);
+
accuracy = score.Accuracy;
scoreMaxCombo = score.MaxCombo;
countGreat = score.Statistics.GetValueOrDefault(HitResult.Great);
@@ -42,13 +46,15 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
countLargeTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
- countSliderEndsDropped = score.Statistics.GetValueOrDefault(HitResult.SmallTickMiss);
- if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
- effectiveMissCount = countMiss;
+
+ if (useSliderHead)
+ countSliderEndsDropped = osuAttributes.SliderCount - score.Statistics.GetValueOrDefault(HitResult.SliderTailHit);
+
+ if (useSliderHead)
+ effectiveMissCount = countMiss;
else
effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
-
double multiplier = PERFORMANCE_BASE_MULTIPLIER;
if (score.Mods.Any(m => m is OsuModNoFail))
@@ -131,7 +137,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (attributes.SliderCount > 0)
{
double estimateSliderEndsDropped;
- if (score.IsLegacyScore)
+ if (useSliderHead)
estimateSliderEndsDropped = Math.Clamp(Math.Min(countOk + countMeh + countMiss, attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
else
estimateSliderEndsDropped = countSliderEndsDropped;
From 77814ec69fa3eabc286bd0e77db3dff7dd7b7ec8 Mon Sep 17 00:00:00 2001
From: Fina <75299710+Finadoggie@users.noreply.github.com>
Date: Fri, 19 Apr 2024 16:04:17 -0700
Subject: [PATCH 087/924] Fix getting slider head drops
---
.../Difficulty/OsuPerformanceCalculator.cs | 16 ++++++----------
1 file changed, 6 insertions(+), 10 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index c78fae1c79..e3dab135dd 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -15,8 +15,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
{
public const double PERFORMANCE_BASE_MULTIPLIER = 1.14; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things.
- private bool useSliderHead;
-
private double accuracy;
private int scoreMaxCombo;
private int countGreat;
@@ -37,8 +35,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
{
var osuAttributes = (OsuDifficultyAttributes)attributes;
- useSliderHead = !score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value);
-
accuracy = score.Accuracy;
scoreMaxCombo = score.MaxCombo;
countGreat = score.Statistics.GetValueOrDefault(HitResult.Great);
@@ -46,12 +42,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
countLargeTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
-
- if (useSliderHead)
+ if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
+ {
countSliderEndsDropped = osuAttributes.SliderCount - score.Statistics.GetValueOrDefault(HitResult.SliderTailHit);
-
- if (useSliderHead)
- effectiveMissCount = countMiss;
+ }
+ if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
+ effectiveMissCount = countMiss;
else
effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
@@ -137,7 +133,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (attributes.SliderCount > 0)
{
double estimateSliderEndsDropped;
- if (useSliderHead)
+ if (score.IsLegacyScore)
estimateSliderEndsDropped = Math.Clamp(Math.Min(countOk + countMeh + countMiss, attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
else
estimateSliderEndsDropped = countSliderEndsDropped;
From 759a82655cf3e741b5c27097a8d6ecddb9a71259 Mon Sep 17 00:00:00 2001
From: Fina <75299710+Finadoggie@users.noreply.github.com>
Date: Fri, 19 Apr 2024 16:04:49 -0700
Subject: [PATCH 088/924] Clamp estimatedSliderEndsDrop
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index e3dab135dd..a2542d83e5 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -136,7 +136,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (score.IsLegacyScore)
estimateSliderEndsDropped = Math.Clamp(Math.Min(countOk + countMeh + countMiss, attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
else
- estimateSliderEndsDropped = countSliderEndsDropped;
+ estimateSliderEndsDropped = Math.Min(countSliderEndsDropped + countLargeTickMiss, estimateDifficultSliders); ;
double sliderNerfFactor = 0;
sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - estimateSliderEndsDropped / estimateDifficultSliders, 3) + attributes.SliderFactor;
From 4a7b8138aeb4cf463a83fd8c51ca31ea22d8fe8f Mon Sep 17 00:00:00 2001
From: Fina <75299710+Finadoggie@users.noreply.github.com>
Date: Fri, 19 Apr 2024 16:07:54 -0700
Subject: [PATCH 089/924] Re-add bool useSliderHead
oops
---
.../Difficulty/OsuPerformanceCalculator.cs | 10 ++++++----
1 file changed, 6 insertions(+), 4 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index a2542d83e5..86f427159a 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -15,6 +15,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
{
public const double PERFORMANCE_BASE_MULTIPLIER = 1.14; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things.
+ private bool useSliderHead;
+
private double accuracy;
private int scoreMaxCombo;
private int countGreat;
@@ -42,12 +44,12 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
countLargeTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
- if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
+ if (useSliderHead)
{
countSliderEndsDropped = osuAttributes.SliderCount - score.Statistics.GetValueOrDefault(HitResult.SliderTailHit);
}
- if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
- effectiveMissCount = countMiss;
+ if (useSliderHead)
+ effectiveMissCount = countMiss;
else
effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
@@ -133,7 +135,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (attributes.SliderCount > 0)
{
double estimateSliderEndsDropped;
- if (score.IsLegacyScore)
+ if (useSliderHead)
estimateSliderEndsDropped = Math.Clamp(Math.Min(countOk + countMeh + countMiss, attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
else
estimateSliderEndsDropped = Math.Min(countSliderEndsDropped + countLargeTickMiss, estimateDifficultSliders); ;
From d1dcac08c6cf05518288fab49b72b2aa093c5c10 Mon Sep 17 00:00:00 2001
From: Fina <75299710+Finadoggie@users.noreply.github.com>
Date: Fri, 19 Apr 2024 16:11:26 -0700
Subject: [PATCH 090/924] fix code formatting
---
.../Difficulty/OsuPerformanceCalculator.cs | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 86f427159a..0a92b724d2 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -44,10 +44,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
countLargeTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
+
if (useSliderHead)
- {
countSliderEndsDropped = osuAttributes.SliderCount - score.Statistics.GetValueOrDefault(HitResult.SliderTailHit);
- }
+
if (useSliderHead)
effectiveMissCount = countMiss;
else
@@ -138,7 +138,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (useSliderHead)
estimateSliderEndsDropped = Math.Clamp(Math.Min(countOk + countMeh + countMiss, attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
else
- estimateSliderEndsDropped = Math.Min(countSliderEndsDropped + countLargeTickMiss, estimateDifficultSliders); ;
+ estimateSliderEndsDropped = Math.Min(countSliderEndsDropped + countLargeTickMiss, estimateDifficultSliders);
double sliderNerfFactor = 0;
sliderNerfFactor = (1 - attributes.SliderFactor) * Math.Pow(1 - estimateSliderEndsDropped / estimateDifficultSliders, 3) + attributes.SliderFactor;
From 4fe55d437a906817e275217e28687f9512e090a8 Mon Sep 17 00:00:00 2001
From: Fina <75299710+Finadoggie@users.noreply.github.com>
Date: Sat, 20 Apr 2024 14:14:57 -0700
Subject: [PATCH 091/924] Renamed useSliderHead to useClassicSlider (and
refactored code accordingly)
---
.../Difficulty/OsuPerformanceCalculator.cs | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 0a92b724d2..23842f4e67 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -15,7 +15,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
{
public const double PERFORMANCE_BASE_MULTIPLIER = 1.14; // This is being adjusted to keep the final pp value scaled around what it used to be when changing things.
- private bool useSliderHead;
+ private bool useClassicSlider;
private double accuracy;
private int scoreMaxCombo;
@@ -36,6 +36,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
protected override PerformanceAttributes CreatePerformanceAttributes(ScoreInfo score, DifficultyAttributes attributes)
{
var osuAttributes = (OsuDifficultyAttributes)attributes;
+ useClassicSlider = score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value);
accuracy = score.Accuracy;
scoreMaxCombo = score.MaxCombo;
@@ -45,13 +46,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
countLargeTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
- if (useSliderHead)
+ if (!useClassicSlider)
countSliderEndsDropped = osuAttributes.SliderCount - score.Statistics.GetValueOrDefault(HitResult.SliderTailHit);
- if (useSliderHead)
- effectiveMissCount = countMiss;
- else
+ if (useClassicSlider)
effectiveMissCount = calculateEffectiveMissCount(osuAttributes);
+ else
+ effectiveMissCount = countMiss;
double multiplier = PERFORMANCE_BASE_MULTIPLIER;
@@ -135,7 +136,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
if (attributes.SliderCount > 0)
{
double estimateSliderEndsDropped;
- if (useSliderHead)
+ if (useClassicSlider)
estimateSliderEndsDropped = Math.Clamp(Math.Min(countOk + countMeh + countMiss, attributes.MaxCombo - scoreMaxCombo), 0, estimateDifficultSliders);
else
estimateSliderEndsDropped = Math.Min(countSliderEndsDropped + countLargeTickMiss, estimateDifficultSliders);
From c1efcc054cf1594d3d883fcf66ab67b811d4de81 Mon Sep 17 00:00:00 2001
From: danielthirtle
Date: Tue, 21 May 2024 21:03:53 +1200
Subject: [PATCH 092/924] Change miss penalty (nerf longer maps)
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 47f6770ce5..36768967ff 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -261,7 +261,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
// Miss penalty assumes that a player will miss on the hardest parts of a map,
// so we use the amount of relatively difficult sections to adjust miss penalty
// to make it more punishing on maps with lower amount of hard sections.
- private double calculateMissPenalty(double missCount, double difficultStrainCount) => 0.94 / ((missCount / (2 * Math.Sqrt(difficultStrainCount))) + 1);
+ private double calculateMissPenalty(double missCount, double difficultStrainCount) => 0.96 / ((missCount / (4 * Math.Pow(Math.Log(difficultStrainCount), 0.94))) + 1);
private double getComboScalingFactor(OsuDifficultyAttributes attributes) => attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(attributes.MaxCombo, 0.8), 1.0);
private int totalHits => countGreat + countOk + countMeh + countMiss;
}
From 20c54ab697eec2bb183a2f7f9ea5022a7b9be66a Mon Sep 17 00:00:00 2001
From: js1086
Date: Thu, 23 May 2024 19:08:32 +0100
Subject: [PATCH 093/924] Apply code quality changes
---
osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs | 3 +--
.../Difficulty/Skills/OsuStrainSkill.cs | 16 ++++++++--------
osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs | 10 ++++------
3 files changed, 13 insertions(+), 16 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
index ad0e3fd107..6c17c84c19 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Aim.cs
@@ -34,8 +34,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
{
currentStrain *= strainDecay(current.DeltaTime);
currentStrain += AimEvaluator.EvaluateDifficultyOf(current, withSliders) * skillMultiplier;
-
- objectStrains.Add(currentStrain);
+ ObjectStrains.Add(currentStrain);
return currentStrain;
}
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index 39175d55e0..c2e9357e3a 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -34,8 +34,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
///
protected virtual double DifficultyMultiplier => DEFAULT_DIFFICULTY_MULTIPLIER;
- protected List objectStrains = new List();
- protected double difficulty;
+ protected List ObjectStrains = new List();
+ protected double Difficulty;
protected OsuStrainSkill(Mod[] mods)
: base(mods)
@@ -44,7 +44,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
public override double DifficultyValue()
{
- difficulty = 0;
+ Difficulty = 0;
double weight = 1;
// Sections with 0 strain are excluded to avoid worst-case time complexity of the following sort (e.g. /b/2351871).
@@ -64,11 +64,11 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
// We're sorting from highest to lowest strain.
foreach (double strain in strains.OrderDescending())
{
- difficulty += strain * weight;
+ Difficulty += strain * weight;
weight *= DecayWeight;
}
- return difficulty * DifficultyMultiplier;
+ return Difficulty * DifficultyMultiplier;
}
///
@@ -77,9 +77,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
///
public double CountDifficultStrains()
{
- double consistentTopStrain = difficulty / 10; // What would the top strain be if all strain values were identical
+ double consistentTopStrain = Difficulty / 10; // What would the top strain be if all strain values were identical
// Use a weighted sum of all strains. Constants are arbitrary and give nice values
- return objectStrains.Sum(s => 1.1 / (1 + Math.Exp(-10 * (s / consistentTopStrain - 0.88))));
+ return ObjectStrains.Sum(s => 1.1 / (1 + Math.Exp(-10 * (s / consistentTopStrain - 0.88))));
}
}
-}
\ No newline at end of file
+}
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
index b1cd0b21d1..bf8e09bd53 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
@@ -41,23 +41,21 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
currentRhythm = RhythmEvaluator.EvaluateDifficultyOf(current);
double totalStrain = currentStrain * currentRhythm;
-
- objectStrains.Add(totalStrain);
+ ObjectStrains.Add(totalStrain);
return totalStrain;
}
public double RelevantNoteCount()
{
- if (objectStrains.Count == 0)
+ if (ObjectStrains.Count == 0)
return 0;
- double maxStrain = objectStrains.Max();
-
+ double maxStrain = ObjectStrains.Max();
if (maxStrain == 0)
return 0;
- return objectStrains.Sum(strain => 1.0 / (1.0 + Math.Exp(-(strain / maxStrain * 12.0 - 6.0))));
+ return ObjectStrains.Sum(strain => 1.0 / (1.0 + Math.Exp(-(strain / maxStrain * 12.0 - 6.0))));
}
}
}
From 1f55c1413bc5fddbae2d9fc932376e189c9c9023 Mon Sep 17 00:00:00 2001
From: Fina <75299710+Finadoggie@users.noreply.github.com>
Date: Fri, 24 May 2024 13:50:26 -0700
Subject: [PATCH 094/924] merged givi's accuracy changes
stat acc save me
---
.../Difficulty/OsuPerformanceCalculator.cs | 24 ++++++++++++++++++-
1 file changed, 23 insertions(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 23842f4e67..fe9d1f1afc 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -46,6 +46,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
countLargeTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
+ if (totalHits > 0) accuracy = calculateEffectiveAccuracy(countGreat, countOk, countMeh, countMiss, osuAttributes);
+
if (!useClassicSlider)
countSliderEndsDropped = osuAttributes.SliderCount - score.Statistics.GetValueOrDefault(HitResult.SliderTailHit);
@@ -192,7 +194,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double relevantCountGreat = Math.Max(0, countGreat - relevantTotalDiff);
double relevantCountOk = Math.Max(0, countOk - Math.Max(0, relevantTotalDiff - countGreat));
double relevantCountMeh = Math.Max(0, countMeh - Math.Max(0, relevantTotalDiff - countGreat - countOk));
- double relevantAccuracy = attributes.SpeedNoteCount == 0 ? 0 : (relevantCountGreat * 6.0 + relevantCountOk * 2.0 + relevantCountMeh) / (attributes.SpeedNoteCount * 6.0);
+ double relevantCountMiss = Math.Max(0, countMiss - Math.Max(0, relevantTotalDiff - countGreat - countOk - countMeh));
+ double relevantAccuracy = attributes.SpeedNoteCount == 0 ? 0 : calculateEffectiveAccuracy(relevantCountGreat, relevantCountOk, relevantCountMeh, relevantCountMiss, attributes);
// Scale the speed value with accuracy and OD.
speedValue *= (0.95 + Math.Pow(attributes.OverallDifficulty, 2) / 750) * Math.Pow((accuracy + relevantAccuracy) / 2.0, (14.5 - Math.Max(attributes.OverallDifficulty, 8)) / 2);
@@ -283,6 +286,25 @@ namespace osu.Game.Rulesets.Osu.Difficulty
return Math.Max(countMiss, comboBasedMissCount);
}
+ // This function is calculating accuracy trying to remove sliders from mistap if slideracc is present
+ // This is wrong way to do this, but doing it right way overnerfs already set scores
+ // This is used to no until the better way (statistical accuracy) to do this is present
+ private double calculateEffectiveAccuracy(double c300, double c100, double c50, double cMiss, OsuDifficultyAttributes attributes)
+ {
+ double accuracy = (c300 * 6 + c100 * 2 + c50) / (c300 + c100 + c50 + cMiss) / 6;
+ if (useClassicSlider) return accuracy;
+
+ // Try to remove sliders from mistakes
+ double mistakesPortion = 1 - accuracy;
+
+ double hitcircleRatio = (double)attributes.HitCircleCount / (attributes.HitCircleCount + attributes.SliderCount);
+ mistakesPortion *= hitcircleRatio;
+
+ accuracy = Math.Max(accuracy, 1 - mistakesPortion);
+
+ return accuracy;
+ }
+
private double getComboScalingFactor(OsuDifficultyAttributes attributes) => attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(attributes.MaxCombo, 0.8), 1.0);
private int totalHits => countGreat + countOk + countMeh + countMiss;
}
From 6c9e906b2d3c89008be590347f2f9e84b3cf9fd2 Mon Sep 17 00:00:00 2001
From: Fina <75299710+Finadoggie@users.noreply.github.com>
Date: Fri, 24 May 2024 14:00:42 -0700
Subject: [PATCH 095/924] Revert "merged givi's accuracy changes"
This reverts commit 1f55c1413bc5fddbae2d9fc932376e189c9c9023.
---
.../Difficulty/OsuPerformanceCalculator.cs | 24 +------------------
1 file changed, 1 insertion(+), 23 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index fe9d1f1afc..23842f4e67 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -46,8 +46,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
countLargeTickMiss = score.Statistics.GetValueOrDefault(HitResult.LargeTickMiss);
- if (totalHits > 0) accuracy = calculateEffectiveAccuracy(countGreat, countOk, countMeh, countMiss, osuAttributes);
-
if (!useClassicSlider)
countSliderEndsDropped = osuAttributes.SliderCount - score.Statistics.GetValueOrDefault(HitResult.SliderTailHit);
@@ -194,8 +192,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
double relevantCountGreat = Math.Max(0, countGreat - relevantTotalDiff);
double relevantCountOk = Math.Max(0, countOk - Math.Max(0, relevantTotalDiff - countGreat));
double relevantCountMeh = Math.Max(0, countMeh - Math.Max(0, relevantTotalDiff - countGreat - countOk));
- double relevantCountMiss = Math.Max(0, countMiss - Math.Max(0, relevantTotalDiff - countGreat - countOk - countMeh));
- double relevantAccuracy = attributes.SpeedNoteCount == 0 ? 0 : calculateEffectiveAccuracy(relevantCountGreat, relevantCountOk, relevantCountMeh, relevantCountMiss, attributes);
+ double relevantAccuracy = attributes.SpeedNoteCount == 0 ? 0 : (relevantCountGreat * 6.0 + relevantCountOk * 2.0 + relevantCountMeh) / (attributes.SpeedNoteCount * 6.0);
// Scale the speed value with accuracy and OD.
speedValue *= (0.95 + Math.Pow(attributes.OverallDifficulty, 2) / 750) * Math.Pow((accuracy + relevantAccuracy) / 2.0, (14.5 - Math.Max(attributes.OverallDifficulty, 8)) / 2);
@@ -286,25 +283,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty
return Math.Max(countMiss, comboBasedMissCount);
}
- // This function is calculating accuracy trying to remove sliders from mistap if slideracc is present
- // This is wrong way to do this, but doing it right way overnerfs already set scores
- // This is used to no until the better way (statistical accuracy) to do this is present
- private double calculateEffectiveAccuracy(double c300, double c100, double c50, double cMiss, OsuDifficultyAttributes attributes)
- {
- double accuracy = (c300 * 6 + c100 * 2 + c50) / (c300 + c100 + c50 + cMiss) / 6;
- if (useClassicSlider) return accuracy;
-
- // Try to remove sliders from mistakes
- double mistakesPortion = 1 - accuracy;
-
- double hitcircleRatio = (double)attributes.HitCircleCount / (attributes.HitCircleCount + attributes.SliderCount);
- mistakesPortion *= hitcircleRatio;
-
- accuracy = Math.Max(accuracy, 1 - mistakesPortion);
-
- return accuracy;
- }
-
private double getComboScalingFactor(OsuDifficultyAttributes attributes) => attributes.MaxCombo <= 0 ? 1.0 : Math.Min(Math.Pow(scoreMaxCombo, 0.8) / Math.Pow(attributes.MaxCombo, 0.8), 1.0);
private int totalHits => countGreat + countOk + countMeh + countMiss;
}
From 61afda1089eeee4d42f59ab6185023d699acb788 Mon Sep 17 00:00:00 2001
From: js1086
Date: Sun, 26 May 2024 11:24:06 +0100
Subject: [PATCH 096/924] Fix NaN case when difficulty is 0
---
osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs | 3 +++
1 file changed, 3 insertions(+)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index c2e9357e3a..af97d90e53 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -77,6 +77,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
///
public double CountDifficultStrains()
{
+ if (double.IsNaN(Difficulty))
+ return 0.0;
+
double consistentTopStrain = Difficulty / 10; // What would the top strain be if all strain values were identical
// Use a weighted sum of all strains. Constants are arbitrary and give nice values
return ObjectStrains.Sum(s => 1.1 / (1 + Math.Exp(-10 * (s / consistentTopStrain - 0.88))));
From c25e1bdeb586db8a2def47232632be61b4d4242e Mon Sep 17 00:00:00 2001
From: js1086
Date: Sun, 26 May 2024 14:21:47 +0100
Subject: [PATCH 097/924] Use correct operation for 0 difficulty case
---
osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
index af97d90e53..ec132237db 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/OsuStrainSkill.cs
@@ -77,7 +77,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
///
public double CountDifficultStrains()
{
- if (double.IsNaN(Difficulty))
+ if (Difficulty == 0)
return 0.0;
double consistentTopStrain = Difficulty / 10; // What would the top strain be if all strain values were identical
From 17145673421118baee2d6971277771625512a78a Mon Sep 17 00:00:00 2001
From: Nathen
Date: Wed, 29 May 2024 09:40:39 -0400
Subject: [PATCH 098/924] Save deviation calculations to variables
---
.../Difficulty/TaikoPerformanceCalculator.cs | 13 ++++++++-----
1 file changed, 8 insertions(+), 5 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index ca11397801..a8ccaedfd0 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -129,6 +129,14 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
const double z = 2.32634787404; // 99% critical value for the normal distribution (one-tailed).
+ double? deviationGreatWindow = calcDeviationGreatWindow();
+ double? deviationGoodWindow = calcDeviationGoodWindow();
+
+ if (deviationGreatWindow is null)
+ return deviationGoodWindow;
+
+ return Math.Min(deviationGreatWindow.Value, deviationGoodWindow!.Value);
+
// The upper bound on deviation, calculated with the ratio of 300s to objects, and the great hit window.
double? calcDeviationGreatWindow()
{
@@ -163,11 +171,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
// We can be 99% confident that the deviation is not higher than:
return h100 / (Math.Sqrt(2) * SpecialFunctions.ErfInv(pLowerBound));
}
-
- if (calcDeviationGreatWindow() is null)
- return calcDeviationGoodWindow();
-
- return Math.Min(calcDeviationGreatWindow()!.Value, calcDeviationGoodWindow()!.Value);
}
private int totalHits => countGreat + countOk + countMeh + countMiss;
From f8f18b6cbd49750916c4fb75b85f0ad93e2f98c4 Mon Sep 17 00:00:00 2001
From: Nathen
Date: Wed, 29 May 2024 09:40:59 -0400
Subject: [PATCH 099/924] Fix naming convention
---
.../Difficulty/TaikoPerformanceAttributes.cs | 4 ++--
.../Difficulty/TaikoPerformanceCalculator.cs | 14 +++++++-------
2 files changed, 9 insertions(+), 9 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
index 6d85aa8f3d..7c74e43db1 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceAttributes.cs
@@ -18,8 +18,8 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
[JsonProperty("effective_miss_count")]
public double EffectiveMissCount { get; set; }
- [JsonProperty("estimated_ur")]
- public double? EstimatedUr { get; set; }
+ [JsonProperty("estimated_unstable_rate")]
+ public double? EstimatedUnstableRate { get; set; }
public override IEnumerable GetAttributesForDisplay()
{
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index a8ccaedfd0..ab809a0ade 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -19,7 +19,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
private int countOk;
private int countMeh;
private int countMiss;
- private double? estimatedUr;
+ private double? estimatedUnstableRate;
private double effectiveMissCount;
@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
countOk = score.Statistics.GetValueOrDefault(HitResult.Ok);
countMeh = score.Statistics.GetValueOrDefault(HitResult.Meh);
countMiss = score.Statistics.GetValueOrDefault(HitResult.Miss);
- estimatedUr = computeDeviationUpperBound(taikoAttributes) * 10;
+ estimatedUnstableRate = computeDeviationUpperBound(taikoAttributes) * 10;
// The effectiveMissCount is calculated by gaining a ratio for totalSuccessfulHits and increasing the miss penalty for shorter object counts lower than 1000.
if (totalSuccessfulHits > 0)
@@ -66,7 +66,7 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
Difficulty = difficultyValue,
Accuracy = accuracyValue,
EffectiveMissCount = effectiveMissCount,
- EstimatedUr = estimatedUr,
+ EstimatedUnstableRate = estimatedUnstableRate,
Total = totalValue
};
}
@@ -92,18 +92,18 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
if (score.Mods.Any(m => m is ModFlashlight))
difficultyValue *= 1.050 * lengthBonus;
- if (estimatedUr == null)
+ if (estimatedUnstableRate == null)
return 0;
- return difficultyValue * Math.Pow(SpecialFunctions.Erf(400 / (Math.Sqrt(2) * estimatedUr.Value)), 2.0);
+ return difficultyValue * Math.Pow(SpecialFunctions.Erf(400 / (Math.Sqrt(2) * estimatedUnstableRate.Value)), 2.0);
}
private double computeAccuracyValue(ScoreInfo score, TaikoDifficultyAttributes attributes, bool isConvert)
{
- if (attributes.GreatHitWindow <= 0 || estimatedUr == null)
+ if (attributes.GreatHitWindow <= 0 || estimatedUnstableRate == null)
return 0;
- double accuracyValue = Math.Pow(70 / estimatedUr.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
+ double accuracyValue = Math.Pow(70 / estimatedUnstableRate.Value, 1.1) * Math.Pow(attributes.StarRating, 0.4) * 100.0;
double lengthBonus = Math.Min(1.15, Math.Pow(totalHits / 1500.0, 0.3));
From e85869e0b48e7d683933ed821f6ec4baa5ea57a3 Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Sun, 2 Jun 2024 16:38:58 +0200
Subject: [PATCH 100/924] Move already placed objects when adjusting offset/BPM
---
.../Screens/Edit/Timing/TapTimingControl.cs | 56 ++++++++++++++++++-
1 file changed, 55 insertions(+), 1 deletion(-)
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index 8cdbd97ecb..cc0d195626 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -1,6 +1,8 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
+using System;
+using System.Collections.Generic;
using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
@@ -9,11 +11,13 @@ using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Shapes;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Input.Events;
+using osu.Framework.Utils;
using osu.Game.Beatmaps.ControlPoints;
using osu.Game.Graphics;
using osu.Game.Graphics.UserInterface;
using osu.Game.Graphics.UserInterfaceV2;
using osu.Game.Overlays;
+using osu.Game.Rulesets.Objects;
using osuTK;
namespace osu.Game.Screens.Edit.Timing
@@ -33,6 +37,8 @@ namespace osu.Game.Screens.Edit.Timing
private MetronomeDisplay metronome = null!;
+ private LabelledSwitchButton adjustPlacedNotes = null!;
+
[BackgroundDependencyLoader]
private void load(OverlayColourProvider colourProvider, OsuColour colours)
{
@@ -59,6 +65,7 @@ namespace osu.Game.Screens.Edit.Timing
{
new Dimension(GridSizeMode.Absolute, 200),
new Dimension(GridSizeMode.Absolute, 50),
+ new Dimension(GridSizeMode.Absolute, 50),
new Dimension(GridSizeMode.Absolute, TapButton.SIZE + padding),
},
Content = new[]
@@ -116,6 +123,18 @@ namespace osu.Game.Screens.Edit.Timing
},
},
new Drawable[]
+ {
+ new Container
+ {
+ RelativeSizeAxes = Axes.Both,
+ Padding = new MarginPadding { Bottom = padding, Horizontal = padding },
+ Children = new Drawable[]
+ {
+ adjustPlacedNotes = new LabelledSwitchButton { Label = "Move already placed notes\nwhen changing the offset/BPM" },
+ }
+ },
+ },
+ new Drawable[]
{
new Container
{
@@ -192,6 +211,17 @@ namespace osu.Game.Screens.Edit.Timing
editorClock.Seek(selectedGroup.Value.Time);
}
+ private List hitObjectsInTimingRange(EditorBeatmap beatmap, ControlPointGroup selectedGroup)
+ {
+ // If the first group, we grab all hitobjects prior to the next, if the last group, we grab all remaining hitobjects
+ double firstGroupTime = beatmap.ControlPointInfo.Groups.Any(x => x.ControlPoints.Any(y => y is TimingControlPoint) && x.Time < selectedGroup.Time) ? selectedGroup.Time : double.MinValue;
+ double nextGroupTime = beatmap.ControlPointInfo.Groups.FirstOrDefault(x => x.ControlPoints.Any(y => y is TimingControlPoint) && x.Time > selectedGroup.Time)?.Time ?? double.MaxValue;
+
+ var result = beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, firstGroupTime) && Precision.DefinitelyBigger(nextGroupTime, x.StartTime)).ToList();
+ Console.WriteLine(firstGroupTime + ", " + nextGroupTime + ", " + result.Count);
+ return result;
+ }
+
private void adjustOffset(double adjust)
{
if (selectedGroup.Value == null)
@@ -199,6 +229,8 @@ namespace osu.Game.Screens.Edit.Timing
bool wasAtStart = editorClock.CurrentTimeAccurate == selectedGroup.Value.Time;
+ List hitObjectsInRange = hitObjectsInTimingRange(beatmap, selectedGroup.Value);
+
// VERY TEMPORARY
var currentGroupItems = selectedGroup.Value.ControlPoints.ToArray();
@@ -212,6 +244,14 @@ namespace osu.Game.Screens.Edit.Timing
// the control point might not necessarily exist yet, if currentGroupItems was empty.
selectedGroup.Value = beatmap.ControlPointInfo.GroupAt(newOffset, true);
+ if (adjustPlacedNotes.Current.Value)
+ {
+ foreach (HitObject hitObject in hitObjectsInRange)
+ {
+ hitObject.StartTime += adjust;
+ }
+ }
+
if (!editorClock.IsRunning && wasAtStart)
editorClock.Seek(newOffset);
}
@@ -223,7 +263,21 @@ namespace osu.Game.Screens.Edit.Timing
if (timing == null)
return;
- timing.BeatLength = 60000 / (timing.BPM + adjust);
+ double newBeatLength = 60000 / (timing.BPM + adjust);
+
+ List hitObjectsInRange = hitObjectsInTimingRange(beatmap, selectedGroup.Value!);
+
+ if (adjustPlacedNotes.Current.Value)
+ {
+ foreach (HitObject hitObject in hitObjectsInRange)
+ {
+ double beat = (hitObject.StartTime - selectedGroup.Value!.Time) / timing.BeatLength;
+
+ hitObject.StartTime = beat * newBeatLength + selectedGroup.Value.Time;
+ }
+ }
+
+ timing.BeatLength = newBeatLength;
}
private partial class InlineButton : OsuButton
From d02c291168af670e66612cda33d35842ec5f05cf Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Sun, 2 Jun 2024 16:42:06 +0200
Subject: [PATCH 101/924] Removed debugging information
---
osu.Game/Screens/Edit/Timing/TapTimingControl.cs | 5 +----
1 file changed, 1 insertion(+), 4 deletions(-)
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index cc0d195626..c4d67eaf1a 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -1,7 +1,6 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
-using System;
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Allocation;
@@ -217,9 +216,7 @@ namespace osu.Game.Screens.Edit.Timing
double firstGroupTime = beatmap.ControlPointInfo.Groups.Any(x => x.ControlPoints.Any(y => y is TimingControlPoint) && x.Time < selectedGroup.Time) ? selectedGroup.Time : double.MinValue;
double nextGroupTime = beatmap.ControlPointInfo.Groups.FirstOrDefault(x => x.ControlPoints.Any(y => y is TimingControlPoint) && x.Time > selectedGroup.Time)?.Time ?? double.MaxValue;
- var result = beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, firstGroupTime) && Precision.DefinitelyBigger(nextGroupTime, x.StartTime)).ToList();
- Console.WriteLine(firstGroupTime + ", " + nextGroupTime + ", " + result.Count);
- return result;
+ return beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, firstGroupTime) && Precision.DefinitelyBigger(nextGroupTime, x.StartTime)).ToList();
}
private void adjustOffset(double adjust)
From 649cfb11fc76b70573fe865f2a4669b1e5a804e9 Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Sun, 2 Jun 2024 16:59:16 +0200
Subject: [PATCH 102/924] To satisfy CodeFactor
---
osu.Game/Screens/Edit/Timing/TapTimingControl.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index c4d67eaf1a..952bdf0ccc 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -270,7 +270,7 @@ namespace osu.Game.Screens.Edit.Timing
{
double beat = (hitObject.StartTime - selectedGroup.Value!.Time) / timing.BeatLength;
- hitObject.StartTime = beat * newBeatLength + selectedGroup.Value.Time;
+ hitObject.StartTime = (beat * newBeatLength) + selectedGroup.Value.Time;
}
}
From a940809fbf8694486f9b1f0c3fb0f6ce243026e7 Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Mon, 3 Jun 2024 14:36:53 +0200
Subject: [PATCH 103/924] Addressed some more code maintainability issues
---
osu.Game/Screens/Edit/Timing/TapTimingControl.cs | 9 +++++----
1 file changed, 5 insertions(+), 4 deletions(-)
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index 952bdf0ccc..6ef7bd1a40 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -3,6 +3,7 @@
using System.Collections.Generic;
using System.Linq;
+using System.Runtime.CompilerServices;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics;
@@ -210,13 +211,13 @@ namespace osu.Game.Screens.Edit.Timing
editorClock.Seek(selectedGroup.Value.Time);
}
- private List hitObjectsInTimingRange(EditorBeatmap beatmap, ControlPointGroup selectedGroup)
+ private static List hitObjectsInTimingRange(EditorBeatmap beatmap, ControlPointGroup selectedGroup)
{
// If the first group, we grab all hitobjects prior to the next, if the last group, we grab all remaining hitobjects
- double firstGroupTime = beatmap.ControlPointInfo.Groups.Any(x => x.ControlPoints.Any(y => y is TimingControlPoint) && x.Time < selectedGroup.Time) ? selectedGroup.Time : double.MinValue;
- double nextGroupTime = beatmap.ControlPointInfo.Groups.FirstOrDefault(x => x.ControlPoints.Any(y => y is TimingControlPoint) && x.Time > selectedGroup.Time)?.Time ?? double.MaxValue;
+ double startTime = beatmap.ControlPointInfo.TimingPoints.Any(x => x.Time < selectedGroup.Time) ? selectedGroup.Time : double.MinValue;
+ double endTime = beatmap.ControlPointInfo.TimingPoints.FirstOrDefault(x => x.Time > selectedGroup.Time)?.Time ?? double.MaxValue;
- return beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, firstGroupTime) && Precision.DefinitelyBigger(nextGroupTime, x.StartTime)).ToList();
+ return beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, startTime) && Precision.DefinitelyBigger(endTime, x.StartTime)).ToList();
}
private void adjustOffset(double adjust)
From 09f3fb9eeea540197032c187688db03e036863bf Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Mon, 3 Jun 2024 23:02:57 +0200
Subject: [PATCH 104/924] Compatible IHasDuration hitobjects now scale with BPM
changes Does not apply to hitobjects with IHasRepeats
---
osu.Game/Screens/Edit/Timing/TapTimingControl.cs | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index 6ef7bd1a40..cffa31d117 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -3,7 +3,6 @@
using System.Collections.Generic;
using System.Linq;
-using System.Runtime.CompilerServices;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics;
@@ -18,6 +17,7 @@ using osu.Game.Graphics.UserInterface;
using osu.Game.Graphics.UserInterfaceV2;
using osu.Game.Overlays;
using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
using osuTK;
namespace osu.Game.Screens.Edit.Timing
@@ -272,6 +272,9 @@ namespace osu.Game.Screens.Edit.Timing
double beat = (hitObject.StartTime - selectedGroup.Value!.Time) / timing.BeatLength;
hitObject.StartTime = (beat * newBeatLength) + selectedGroup.Value.Time;
+
+ if (hitObject is not IHasRepeats && hitObject is IHasDuration hitObjectWithDuration)
+ hitObjectWithDuration.Duration *= newBeatLength / timing.BeatLength;
}
}
From 3d5a04ac99d4b9f2002a24206106472c53da5c7b Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Wed, 5 Jun 2024 17:57:44 +0200
Subject: [PATCH 105/924] HitObject has defaults applied on bpm/offset
adjustment
---
osu.Game/Screens/Edit/Timing/TapTimingControl.cs | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index cffa31d117..739b9894ce 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -252,6 +252,9 @@ namespace osu.Game.Screens.Edit.Timing
if (!editorClock.IsRunning && wasAtStart)
editorClock.Seek(newOffset);
+
+ foreach (HitObject hitObject in hitObjectsInRange)
+ hitObject.ApplyDefaults(beatmap.ControlPointInfo, beatmap.Difficulty);
}
private void adjustBpm(double adjust)
@@ -279,6 +282,9 @@ namespace osu.Game.Screens.Edit.Timing
}
timing.BeatLength = newBeatLength;
+
+ foreach (HitObject hitObject in hitObjectsInRange)
+ hitObject.ApplyDefaults(beatmap.ControlPointInfo, beatmap.Difficulty);
}
private partial class InlineButton : OsuButton
From 2db55f9379d6171ac9b583a883301d07dc03446a Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Fri, 7 Jun 2024 08:21:09 +0200
Subject: [PATCH 106/924] Change HitObject update call to use established
patterns
---
osu.Game/Screens/Edit/Timing/TapTimingControl.cs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index 739b9894ce..1c7f89c80d 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -254,7 +254,7 @@ namespace osu.Game.Screens.Edit.Timing
editorClock.Seek(newOffset);
foreach (HitObject hitObject in hitObjectsInRange)
- hitObject.ApplyDefaults(beatmap.ControlPointInfo, beatmap.Difficulty);
+ beatmap.Update(hitObject);
}
private void adjustBpm(double adjust)
@@ -284,7 +284,7 @@ namespace osu.Game.Screens.Edit.Timing
timing.BeatLength = newBeatLength;
foreach (HitObject hitObject in hitObjectsInRange)
- hitObject.ApplyDefaults(beatmap.ControlPointInfo, beatmap.Difficulty);
+ beatmap.Update(hitObject);
}
private partial class InlineButton : OsuButton
From 559f94aa02a138154a136fbb1708ca01d83b3b5b Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Fri, 7 Jun 2024 21:57:12 +0200
Subject: [PATCH 107/924] Moved HitObject adjustments to TimingControlPoint
---
.../ControlPoints/TimingControlPoint.cs | 35 +++++++++++++++
.../Screens/Edit/Timing/TapTimingControl.cs | 44 ++++---------------
2 files changed, 43 insertions(+), 36 deletions(-)
diff --git a/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs b/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
index 4e69486e2d..a3224a6ab9 100644
--- a/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
+++ b/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
@@ -2,9 +2,14 @@
// See the LICENCE file in the repository root for full licence text.
using System;
+using System.Collections.Generic;
+using System.Linq;
using osu.Framework.Bindables;
+using osu.Framework.Utils;
using osu.Game.Beatmaps.Timing;
using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
using osuTK.Graphics;
namespace osu.Game.Beatmaps.ControlPoints
@@ -105,5 +110,35 @@ namespace osu.Game.Beatmaps.ControlPoints
&& BeatLength.Equals(other.BeatLength);
public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), TimeSignature, BeatLength, OmitFirstBarLine);
+
+ public List HitObjectsInTimingRange(IBeatmap beatmap)
+ {
+ // If the first group, we grab all hitobjects prior to the next, if the last group, we grab all remaining hitobjects
+ double startTime = beatmap.ControlPointInfo.TimingPoints.Any(x => x.Time < Time) ? Time : double.MinValue;
+ double endTime = beatmap.ControlPointInfo.TimingPoints.FirstOrDefault(x => x.Time > Time)?.Time ?? double.MaxValue;
+
+ return beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, startTime) && Precision.DefinitelyBigger(endTime, x.StartTime)).ToList();
+ }
+
+ public void AdjustHitObjectOffset(IBeatmap beatmap, double adjust)
+ {
+ foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap))
+ {
+ hitObject.StartTime += adjust;
+ }
+ }
+
+ public void SetHitObjectBPM(IBeatmap beatmap, double newBeatLength)
+ {
+ foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap))
+ {
+ double beat = (hitObject.StartTime - Time) / BeatLength;
+
+ hitObject.StartTime = (beat * newBeatLength) + Time;
+
+ if (hitObject is not IHasRepeats && hitObject is IHasDuration hitObjectWithDuration)
+ hitObjectWithDuration.Duration *= newBeatLength / BeatLength;
+ }
+ }
}
}
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index 1c7f89c80d..49d3df4aef 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -211,15 +211,6 @@ namespace osu.Game.Screens.Edit.Timing
editorClock.Seek(selectedGroup.Value.Time);
}
- private static List hitObjectsInTimingRange(EditorBeatmap beatmap, ControlPointGroup selectedGroup)
- {
- // If the first group, we grab all hitobjects prior to the next, if the last group, we grab all remaining hitobjects
- double startTime = beatmap.ControlPointInfo.TimingPoints.Any(x => x.Time < selectedGroup.Time) ? selectedGroup.Time : double.MinValue;
- double endTime = beatmap.ControlPointInfo.TimingPoints.FirstOrDefault(x => x.Time > selectedGroup.Time)?.Time ?? double.MaxValue;
-
- return beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, startTime) && Precision.DefinitelyBigger(endTime, x.StartTime)).ToList();
- }
-
private void adjustOffset(double adjust)
{
if (selectedGroup.Value == null)
@@ -227,8 +218,6 @@ namespace osu.Game.Screens.Edit.Timing
bool wasAtStart = editorClock.CurrentTimeAccurate == selectedGroup.Value.Time;
- List hitObjectsInRange = hitObjectsInTimingRange(beatmap, selectedGroup.Value);
-
// VERY TEMPORARY
var currentGroupItems = selectedGroup.Value.ControlPoints.ToArray();
@@ -237,26 +226,22 @@ namespace osu.Game.Screens.Edit.Timing
double newOffset = selectedGroup.Value.Time + adjust;
foreach (var cp in currentGroupItems)
+ {
+ if (adjustPlacedNotes.Current.Value && cp is TimingControlPoint tp)
+ tp.AdjustHitObjectOffset(beatmap, adjust);
beatmap.ControlPointInfo.Add(newOffset, cp);
+ }
// the control point might not necessarily exist yet, if currentGroupItems was empty.
selectedGroup.Value = beatmap.ControlPointInfo.GroupAt(newOffset, true);
- if (adjustPlacedNotes.Current.Value)
- {
- foreach (HitObject hitObject in hitObjectsInRange)
- {
- hitObject.StartTime += adjust;
- }
- }
-
if (!editorClock.IsRunning && wasAtStart)
editorClock.Seek(newOffset);
- foreach (HitObject hitObject in hitObjectsInRange)
- beatmap.Update(hitObject);
+ beatmap.UpdateAllHitObjects();
}
+
private void adjustBpm(double adjust)
{
var timing = selectedGroup.Value?.ControlPoints.OfType().FirstOrDefault();
@@ -266,25 +251,12 @@ namespace osu.Game.Screens.Edit.Timing
double newBeatLength = 60000 / (timing.BPM + adjust);
- List hitObjectsInRange = hitObjectsInTimingRange(beatmap, selectedGroup.Value!);
-
if (adjustPlacedNotes.Current.Value)
- {
- foreach (HitObject hitObject in hitObjectsInRange)
- {
- double beat = (hitObject.StartTime - selectedGroup.Value!.Time) / timing.BeatLength;
-
- hitObject.StartTime = (beat * newBeatLength) + selectedGroup.Value.Time;
-
- if (hitObject is not IHasRepeats && hitObject is IHasDuration hitObjectWithDuration)
- hitObjectWithDuration.Duration *= newBeatLength / timing.BeatLength;
- }
- }
+ timing.SetHitObjectBPM(beatmap, newBeatLength);
timing.BeatLength = newBeatLength;
- foreach (HitObject hitObject in hitObjectsInRange)
- beatmap.Update(hitObject);
+ beatmap.UpdateAllHitObjects();
}
private partial class InlineButton : OsuButton
From ac0c425e2921a2b84467b4703eacff35d380dba7 Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Sun, 9 Jun 2024 11:27:53 +0200
Subject: [PATCH 108/924] Moved setting to the menu bar
---
.../ControlPoints/TimingControlPoint.cs | 8 +++---
osu.Game/Localisation/EditorStrings.cs | 5 ++++
osu.Game/Screens/Edit/Editor.cs | 6 ++++-
osu.Game/Screens/Edit/EditorBeatmap.cs | 2 ++
.../Screens/Edit/Timing/TapTimingControl.cs | 25 +++----------------
5 files changed, 20 insertions(+), 26 deletions(-)
diff --git a/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs b/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
index a3224a6ab9..234a34dc87 100644
--- a/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
+++ b/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
@@ -128,16 +128,16 @@ namespace osu.Game.Beatmaps.ControlPoints
}
}
- public void SetHitObjectBPM(IBeatmap beatmap, double newBeatLength)
+ public void SetHitObjectBPM(IBeatmap beatmap, double oldBeatLength)
{
foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap))
{
- double beat = (hitObject.StartTime - Time) / BeatLength;
+ double beat = (hitObject.StartTime - Time) / oldBeatLength;
- hitObject.StartTime = (beat * newBeatLength) + Time;
+ hitObject.StartTime = (beat * BeatLength) + Time;
if (hitObject is not IHasRepeats && hitObject is IHasDuration hitObjectWithDuration)
- hitObjectWithDuration.Duration *= newBeatLength / BeatLength;
+ hitObjectWithDuration.Duration *= BeatLength / oldBeatLength;
}
}
}
diff --git a/osu.Game/Localisation/EditorStrings.cs b/osu.Game/Localisation/EditorStrings.cs
index 6ad12f54df..b604fc3889 100644
--- a/osu.Game/Localisation/EditorStrings.cs
+++ b/osu.Game/Localisation/EditorStrings.cs
@@ -39,6 +39,11 @@ namespace osu.Game.Localisation
///
public static LocalisableString SetPreviewPointToCurrent => new TranslatableString(getKey(@"set_preview_point_to_current"), @"Set preview point to current time");
+ ///
+ /// "Move already placed notes when changing the offset / BPM"
+ ///
+ public static LocalisableString AdjustNotesOnOffsetBPMChange => new TranslatableString(getKey(@"adjust_notes_on_offset_bpm_change"), @"Move already placed notes when changing the offset / BPM");
+
///
/// "For editing (.olz)"
///
diff --git a/osu.Game/Screens/Edit/Editor.cs b/osu.Game/Screens/Edit/Editor.cs
index 07c32983f5..af099413fd 100644
--- a/osu.Game/Screens/Edit/Editor.cs
+++ b/osu.Game/Screens/Edit/Editor.cs
@@ -367,7 +367,11 @@ namespace osu.Game.Screens.Edit
{
Items = new MenuItem[]
{
- new EditorMenuItem(EditorStrings.SetPreviewPointToCurrent, MenuItemType.Standard, SetPreviewPointToCurrentTime)
+ new EditorMenuItem(EditorStrings.SetPreviewPointToCurrent, MenuItemType.Standard, SetPreviewPointToCurrentTime),
+ new ToggleMenuItem(EditorStrings.AdjustNotesOnOffsetBPMChange)
+ {
+ State = { BindTarget = editorBeatmap.AdjustNotesOnOffsetBPMChange },
+ }
}
}
}
diff --git a/osu.Game/Screens/Edit/EditorBeatmap.cs b/osu.Game/Screens/Edit/EditorBeatmap.cs
index 7a3ea474fb..42a3a6d3b2 100644
--- a/osu.Game/Screens/Edit/EditorBeatmap.cs
+++ b/osu.Game/Screens/Edit/EditorBeatmap.cs
@@ -88,6 +88,8 @@ namespace osu.Game.Screens.Edit
public BindableInt PreviewTime { get; }
+ public Bindable AdjustNotesOnOffsetBPMChange { get; } = new Bindable(false);
+
private readonly IBeatmapProcessor beatmapProcessor;
private readonly Dictionary> startTimeBindables = new Dictionary>();
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index 49d3df4aef..30e5919411 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -37,8 +37,6 @@ namespace osu.Game.Screens.Edit.Timing
private MetronomeDisplay metronome = null!;
- private LabelledSwitchButton adjustPlacedNotes = null!;
-
[BackgroundDependencyLoader]
private void load(OverlayColourProvider colourProvider, OsuColour colours)
{
@@ -65,7 +63,6 @@ namespace osu.Game.Screens.Edit.Timing
{
new Dimension(GridSizeMode.Absolute, 200),
new Dimension(GridSizeMode.Absolute, 50),
- new Dimension(GridSizeMode.Absolute, 50),
new Dimension(GridSizeMode.Absolute, TapButton.SIZE + padding),
},
Content = new[]
@@ -123,18 +120,6 @@ namespace osu.Game.Screens.Edit.Timing
},
},
new Drawable[]
- {
- new Container
- {
- RelativeSizeAxes = Axes.Both,
- Padding = new MarginPadding { Bottom = padding, Horizontal = padding },
- Children = new Drawable[]
- {
- adjustPlacedNotes = new LabelledSwitchButton { Label = "Move already placed notes\nwhen changing the offset/BPM" },
- }
- },
- },
- new Drawable[]
{
new Container
{
@@ -227,7 +212,7 @@ namespace osu.Game.Screens.Edit.Timing
foreach (var cp in currentGroupItems)
{
- if (adjustPlacedNotes.Current.Value && cp is TimingControlPoint tp)
+ if (beatmap.AdjustNotesOnOffsetBPMChange.Value && cp is TimingControlPoint tp)
tp.AdjustHitObjectOffset(beatmap, adjust);
beatmap.ControlPointInfo.Add(newOffset, cp);
}
@@ -249,12 +234,10 @@ namespace osu.Game.Screens.Edit.Timing
if (timing == null)
return;
- double newBeatLength = 60000 / (timing.BPM + adjust);
+ timing.BeatLength = 60000 / (timing.BPM + adjust);
- if (adjustPlacedNotes.Current.Value)
- timing.SetHitObjectBPM(beatmap, newBeatLength);
-
- timing.BeatLength = newBeatLength;
+ if (beatmap.AdjustNotesOnOffsetBPMChange.Value)
+ timing.SetHitObjectBPM(beatmap, 60000 / (timing.BPM - adjust));
beatmap.UpdateAllHitObjects();
}
From 33d0d4c8f22b284c784a55ab8e143781a580ed16 Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Sun, 9 Jun 2024 11:29:25 +0200
Subject: [PATCH 109/924] Fixed certain UI elements not working for HitObject
BPM/Offset adjustment
---
osu.Game/Screens/Edit/Timing/GroupSection.cs | 7 +++++++
osu.Game/Screens/Edit/Timing/TapTimingControl.cs | 5 -----
osu.Game/Screens/Edit/Timing/TimingSection.cs | 11 +++++++++++
3 files changed, 18 insertions(+), 5 deletions(-)
diff --git a/osu.Game/Screens/Edit/Timing/GroupSection.cs b/osu.Game/Screens/Edit/Timing/GroupSection.cs
index 487a871881..7d0eab1f7f 100644
--- a/osu.Game/Screens/Edit/Timing/GroupSection.cs
+++ b/osu.Game/Screens/Edit/Timing/GroupSection.cs
@@ -109,11 +109,18 @@ namespace osu.Game.Screens.Edit.Timing
Beatmap.ControlPointInfo.RemoveGroup(SelectedGroup.Value);
foreach (var cp in currentGroupItems)
+ {
+ // Only adjust hit object offsets if the group contains a timing control point
+ if (Beatmap.AdjustNotesOnOffsetBPMChange.Value && cp is TimingControlPoint tp)
+ tp.AdjustHitObjectOffset(Beatmap, time - SelectedGroup.Value.Time);
Beatmap.ControlPointInfo.Add(time, cp);
+ }
// the control point might not necessarily exist yet, if currentGroupItems was empty.
SelectedGroup.Value = Beatmap.ControlPointInfo.GroupAt(time, true);
+ Beatmap.UpdateAllHitObjects();
+
changeHandler?.EndChange();
}
}
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index 30e5919411..937235c7bc 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -1,7 +1,6 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
-using System.Collections.Generic;
using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
@@ -10,14 +9,11 @@ using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Shapes;
using osu.Framework.Graphics.Sprites;
using osu.Framework.Input.Events;
-using osu.Framework.Utils;
using osu.Game.Beatmaps.ControlPoints;
using osu.Game.Graphics;
using osu.Game.Graphics.UserInterface;
using osu.Game.Graphics.UserInterfaceV2;
using osu.Game.Overlays;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
using osuTK;
namespace osu.Game.Screens.Edit.Timing
@@ -226,7 +222,6 @@ namespace osu.Game.Screens.Edit.Timing
beatmap.UpdateAllHitObjects();
}
-
private void adjustBpm(double adjust)
{
var timing = selectedGroup.Value?.ControlPoints.OfType().FirstOrDefault();
diff --git a/osu.Game/Screens/Edit/Timing/TimingSection.cs b/osu.Game/Screens/Edit/Timing/TimingSection.cs
index 2757753b07..24cf865ce3 100644
--- a/osu.Game/Screens/Edit/Timing/TimingSection.cs
+++ b/osu.Game/Screens/Edit/Timing/TimingSection.cs
@@ -42,6 +42,17 @@ namespace osu.Game.Screens.Edit.Timing
{
if (!isRebinding) ChangeHandler?.SaveState();
}
+
+ bpmTextEntry.Bindable.BindValueChanged(val =>
+ {
+ if (ControlPoint.Value == null)
+ return;
+
+ ChangeHandler?.BeginChange();
+ ControlPoint.Value.SetHitObjectBPM(Beatmap, val.OldValue);
+ Beatmap.UpdateAllHitObjects();
+ ChangeHandler?.EndChange();
+ });
}
private bool isRebinding;
From 101887d3154306e53021352f47c609f90362c913 Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Sun, 9 Jun 2024 18:04:27 +0200
Subject: [PATCH 110/924] Notes aren't adjusted if setting is off
---
osu.Game/Screens/Edit/Timing/TimingSection.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game/Screens/Edit/Timing/TimingSection.cs b/osu.Game/Screens/Edit/Timing/TimingSection.cs
index 24cf865ce3..1ae85e6c9e 100644
--- a/osu.Game/Screens/Edit/Timing/TimingSection.cs
+++ b/osu.Game/Screens/Edit/Timing/TimingSection.cs
@@ -45,7 +45,7 @@ namespace osu.Game.Screens.Edit.Timing
bpmTextEntry.Bindable.BindValueChanged(val =>
{
- if (ControlPoint.Value == null)
+ if (!Beatmap.AdjustNotesOnOffsetBPMChange.Value || ControlPoint.Value == null)
return;
ChangeHandler?.BeginChange();
From 9906ab3449719c0d01b3f847edbabe73359a3d95 Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Wed, 12 Jun 2024 19:25:48 +0200
Subject: [PATCH 111/924] Fixed double adjustment of hitobject beatlength
---
osu.Game/Screens/Edit/Timing/TapTimingControl.cs | 3 ---
osu.Game/Screens/Edit/Timing/TimingSection.cs | 2 --
2 files changed, 5 deletions(-)
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index 937235c7bc..55404702ac 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -231,9 +231,6 @@ namespace osu.Game.Screens.Edit.Timing
timing.BeatLength = 60000 / (timing.BPM + adjust);
- if (beatmap.AdjustNotesOnOffsetBPMChange.Value)
- timing.SetHitObjectBPM(beatmap, 60000 / (timing.BPM - adjust));
-
beatmap.UpdateAllHitObjects();
}
diff --git a/osu.Game/Screens/Edit/Timing/TimingSection.cs b/osu.Game/Screens/Edit/Timing/TimingSection.cs
index 1ae85e6c9e..5be1de467d 100644
--- a/osu.Game/Screens/Edit/Timing/TimingSection.cs
+++ b/osu.Game/Screens/Edit/Timing/TimingSection.cs
@@ -48,10 +48,8 @@ namespace osu.Game.Screens.Edit.Timing
if (!Beatmap.AdjustNotesOnOffsetBPMChange.Value || ControlPoint.Value == null)
return;
- ChangeHandler?.BeginChange();
ControlPoint.Value.SetHitObjectBPM(Beatmap, val.OldValue);
Beatmap.UpdateAllHitObjects();
- ChangeHandler?.EndChange();
});
}
From 9b076a8b03f7f7258e2c20b237ab94490c245e42 Mon Sep 17 00:00:00 2001
From: Aurelian
Date: Wed, 12 Jun 2024 19:57:17 +0200
Subject: [PATCH 112/924] Moved HitObject adjustment methods to a static helper
class
---
.../ControlPoints/TimingControlPoint.cs | 35 ----------------
osu.Game/Screens/Edit/Timing/GroupSection.cs | 2 +-
.../Screens/Edit/Timing/TapTimingControl.cs | 2 +-
osu.Game/Screens/Edit/Timing/TimingSection.cs | 41 ++++++++++++++++++-
4 files changed, 42 insertions(+), 38 deletions(-)
diff --git a/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs b/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
index 234a34dc87..4e69486e2d 100644
--- a/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
+++ b/osu.Game/Beatmaps/ControlPoints/TimingControlPoint.cs
@@ -2,14 +2,9 @@
// See the LICENCE file in the repository root for full licence text.
using System;
-using System.Collections.Generic;
-using System.Linq;
using osu.Framework.Bindables;
-using osu.Framework.Utils;
using osu.Game.Beatmaps.Timing;
using osu.Game.Graphics;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
using osuTK.Graphics;
namespace osu.Game.Beatmaps.ControlPoints
@@ -110,35 +105,5 @@ namespace osu.Game.Beatmaps.ControlPoints
&& BeatLength.Equals(other.BeatLength);
public override int GetHashCode() => HashCode.Combine(base.GetHashCode(), TimeSignature, BeatLength, OmitFirstBarLine);
-
- public List HitObjectsInTimingRange(IBeatmap beatmap)
- {
- // If the first group, we grab all hitobjects prior to the next, if the last group, we grab all remaining hitobjects
- double startTime = beatmap.ControlPointInfo.TimingPoints.Any(x => x.Time < Time) ? Time : double.MinValue;
- double endTime = beatmap.ControlPointInfo.TimingPoints.FirstOrDefault(x => x.Time > Time)?.Time ?? double.MaxValue;
-
- return beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, startTime) && Precision.DefinitelyBigger(endTime, x.StartTime)).ToList();
- }
-
- public void AdjustHitObjectOffset(IBeatmap beatmap, double adjust)
- {
- foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap))
- {
- hitObject.StartTime += adjust;
- }
- }
-
- public void SetHitObjectBPM(IBeatmap beatmap, double oldBeatLength)
- {
- foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap))
- {
- double beat = (hitObject.StartTime - Time) / oldBeatLength;
-
- hitObject.StartTime = (beat * BeatLength) + Time;
-
- if (hitObject is not IHasRepeats && hitObject is IHasDuration hitObjectWithDuration)
- hitObjectWithDuration.Duration *= BeatLength / oldBeatLength;
- }
- }
}
}
diff --git a/osu.Game/Screens/Edit/Timing/GroupSection.cs b/osu.Game/Screens/Edit/Timing/GroupSection.cs
index 7d0eab1f7f..c5a4422192 100644
--- a/osu.Game/Screens/Edit/Timing/GroupSection.cs
+++ b/osu.Game/Screens/Edit/Timing/GroupSection.cs
@@ -112,7 +112,7 @@ namespace osu.Game.Screens.Edit.Timing
{
// Only adjust hit object offsets if the group contains a timing control point
if (Beatmap.AdjustNotesOnOffsetBPMChange.Value && cp is TimingControlPoint tp)
- tp.AdjustHitObjectOffset(Beatmap, time - SelectedGroup.Value.Time);
+ TimingSectionAdjustments.AdjustHitObjectOffset(Beatmap, tp, time - SelectedGroup.Value.Time);
Beatmap.ControlPointInfo.Add(time, cp);
}
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index 55404702ac..f2e37369d1 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -209,7 +209,7 @@ namespace osu.Game.Screens.Edit.Timing
foreach (var cp in currentGroupItems)
{
if (beatmap.AdjustNotesOnOffsetBPMChange.Value && cp is TimingControlPoint tp)
- tp.AdjustHitObjectOffset(beatmap, adjust);
+ TimingSectionAdjustments.AdjustHitObjectOffset(beatmap, tp, adjust);
beatmap.ControlPointInfo.Add(newOffset, cp);
}
diff --git a/osu.Game/Screens/Edit/Timing/TimingSection.cs b/osu.Game/Screens/Edit/Timing/TimingSection.cs
index 5be1de467d..ba335d55eb 100644
--- a/osu.Game/Screens/Edit/Timing/TimingSection.cs
+++ b/osu.Game/Screens/Edit/Timing/TimingSection.cs
@@ -1,11 +1,17 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
+using System.Collections.Generic;
+using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
using osu.Game.Beatmaps.ControlPoints;
using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
namespace osu.Game.Screens.Edit.Timing
{
@@ -48,7 +54,7 @@ namespace osu.Game.Screens.Edit.Timing
if (!Beatmap.AdjustNotesOnOffsetBPMChange.Value || ControlPoint.Value == null)
return;
- ControlPoint.Value.SetHitObjectBPM(Beatmap, val.OldValue);
+ TimingSectionAdjustments.SetHitObjectBPM(Beatmap, ControlPoint.Value, val.OldValue);
Beatmap.UpdateAllHitObjects();
});
}
@@ -128,4 +134,37 @@ namespace osu.Game.Screens.Edit.Timing
private static double beatLengthToBpm(double beatLength) => 60000 / beatLength;
}
+
+ public static class TimingSectionAdjustments
+ {
+ public static List HitObjectsInTimingRange(IBeatmap beatmap, double time)
+ {
+ // If the first group, we grab all hitobjects prior to the next, if the last group, we grab all remaining hitobjects
+ double startTime = beatmap.ControlPointInfo.TimingPoints.Any(x => x.Time < time) ? time : double.MinValue;
+ double endTime = beatmap.ControlPointInfo.TimingPoints.FirstOrDefault(x => x.Time > time)?.Time ?? double.MaxValue;
+
+ return beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, startTime) && Precision.DefinitelyBigger(endTime, x.StartTime)).ToList();
+ }
+
+ public static void AdjustHitObjectOffset(IBeatmap beatmap, TimingControlPoint timingControlPoint, double adjust)
+ {
+ foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap, timingControlPoint.Time))
+ {
+ hitObject.StartTime += adjust;
+ }
+ }
+
+ public static void SetHitObjectBPM(IBeatmap beatmap, TimingControlPoint timingControlPoint, double oldBeatLength)
+ {
+ foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap, timingControlPoint.Time))
+ {
+ double beat = (hitObject.StartTime - timingControlPoint.Time) / oldBeatLength;
+
+ hitObject.StartTime = (beat * timingControlPoint.BeatLength) + timingControlPoint.Time;
+
+ if (hitObject is not IHasRepeats && hitObject is IHasDuration hitObjectWithDuration)
+ hitObjectWithDuration.Duration *= timingControlPoint.BeatLength / oldBeatLength;
+ }
+ }
+ }
}
From 2fb22f1febef5ad5ab120c24875e69b798ed984e Mon Sep 17 00:00:00 2001
From: Nathen
Date: Sun, 23 Jun 2024 19:17:19 -0400
Subject: [PATCH 113/924] Move the return value for deviation below the local
functions
---
.../Difficulty/TaikoPerformanceCalculator.cs | 16 ++++++++--------
1 file changed, 8 insertions(+), 8 deletions(-)
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
index ab809a0ade..e42b015176 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoPerformanceCalculator.cs
@@ -129,14 +129,6 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
const double z = 2.32634787404; // 99% critical value for the normal distribution (one-tailed).
- double? deviationGreatWindow = calcDeviationGreatWindow();
- double? deviationGoodWindow = calcDeviationGoodWindow();
-
- if (deviationGreatWindow is null)
- return deviationGoodWindow;
-
- return Math.Min(deviationGreatWindow.Value, deviationGoodWindow!.Value);
-
// The upper bound on deviation, calculated with the ratio of 300s to objects, and the great hit window.
double? calcDeviationGreatWindow()
{
@@ -171,6 +163,14 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
// We can be 99% confident that the deviation is not higher than:
return h100 / (Math.Sqrt(2) * SpecialFunctions.ErfInv(pLowerBound));
}
+
+ double? deviationGreatWindow = calcDeviationGreatWindow();
+ double? deviationGoodWindow = calcDeviationGoodWindow();
+
+ if (deviationGreatWindow is null)
+ return deviationGoodWindow;
+
+ return Math.Min(deviationGreatWindow.Value, deviationGoodWindow!.Value);
}
private int totalHits => countGreat + countOk + countMeh + countMiss;
From b15028a918ececff597d694c3315d732cf784cdc Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Wed, 3 Jul 2024 12:36:12 +0200
Subject: [PATCH 114/924] fixes
---
osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs | 10 +---------
1 file changed, 1 insertion(+), 9 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
index 8d80ed651e..7720afe60a 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
@@ -3,6 +3,7 @@
using System.Collections.Generic;
using System.Linq;
+using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Primitives;
using osu.Framework.Graphics.UserInterface;
@@ -23,18 +24,9 @@ namespace osu.Game.Rulesets.Osu.Edit
{
public partial class OsuSelectionHandler : EditorSelectionHandler
{
- [Resolved(CanBeNull = true)]
- private IDistanceSnapProvider? snapProvider { get; set; }
-
[Resolved]
private OsuGridToolboxGroup gridToolbox { get; set; } = null!;
- ///
- /// During a transform, the initial path types of a single selected slider are stored so they
- /// can be maintained throughout the operation.
- ///
- private List? referencePathTypes;
-
protected override void OnSelectionChanged()
{
base.OnSelectionChanged();
From 5f8512896e0eee0eda8ec0c9410704422d475182 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Wed, 3 Jul 2024 12:40:22 +0200
Subject: [PATCH 115/924] use grid origin in scale tool
---
osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs | 8 +++++---
osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs | 2 +-
2 files changed, 6 insertions(+), 4 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
index a299eebbce..65a07e2e2f 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
@@ -10,7 +10,6 @@ using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites;
using osu.Game.Graphics.UserInterface;
using osu.Game.Graphics.UserInterfaceV2;
-using osu.Game.Rulesets.Osu.UI;
using osu.Game.Screens.Edit.Components.RadioButtons;
using osuTK;
@@ -20,6 +19,8 @@ namespace osu.Game.Rulesets.Osu.Edit
{
private readonly OsuSelectionScaleHandler scaleHandler;
+ private readonly OsuGridToolboxGroup gridToolbox;
+
private readonly Bindable scaleInfo = new Bindable(new PreciseScaleInfo(1, ScaleOrigin.PlayfieldCentre, true, true));
private SliderWithTextBoxInput scaleInput = null!;
@@ -32,9 +33,10 @@ namespace osu.Game.Rulesets.Osu.Edit
private OsuCheckbox xCheckBox = null!;
private OsuCheckbox yCheckBox = null!;
- public PreciseScalePopover(OsuSelectionScaleHandler scaleHandler)
+ public PreciseScalePopover(OsuSelectionScaleHandler scaleHandler, OsuGridToolboxGroup gridToolbox)
{
this.scaleHandler = scaleHandler;
+ this.gridToolbox = gridToolbox;
AllowableAnchors = new[] { Anchor.CentreLeft, Anchor.CentreRight };
}
@@ -179,7 +181,7 @@ namespace osu.Game.Rulesets.Osu.Edit
updateAxisCheckBoxesEnabled();
}
- private Vector2? getOriginPosition(PreciseScaleInfo scale) => scale.Origin == ScaleOrigin.PlayfieldCentre ? OsuPlayfield.BASE_SIZE / 2 : null;
+ private Vector2? getOriginPosition(PreciseScaleInfo scale) => scale.Origin == ScaleOrigin.PlayfieldCentre ? gridToolbox.StartPosition.Value : null;
private void setAxis(bool x, bool y)
{
diff --git a/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs b/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
index 2e4d7e8b91..a41412cbe3 100644
--- a/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
+++ b/osu.Game.Rulesets.Osu/Edit/TransformToolboxGroup.cs
@@ -49,7 +49,7 @@ namespace osu.Game.Rulesets.Osu.Edit
() => new PreciseRotationPopover(RotationHandler, GridToolbox)),
scaleButton = new EditorToolButton("Scale",
() => new SpriteIcon { Icon = FontAwesome.Solid.ArrowsAlt },
- () => new PreciseScalePopover(ScaleHandler))
+ () => new PreciseScalePopover(ScaleHandler, GridToolbox))
}
};
}
From d0715c5f12a98e9a31465600d1cc69bb0efe1df2 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Wed, 3 Jul 2024 16:23:19 +0200
Subject: [PATCH 116/924] scale along rotated axis
---
.../Edit/OsuSelectionScaleHandler.cs | 104 ++++++++++++++----
.../Edit/PreciseScalePopover.cs | 8 +-
.../Editing/TestSceneComposeSelectBox.cs | 2 +-
.../SkinEditor/SkinSelectionScaleHandler.cs | 2 +-
.../Components/SelectionScaleHandler.cs | 8 +-
osu.Game/Utils/GeometryUtils.cs | 4 +-
6 files changed, 97 insertions(+), 31 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
index f4fd48f183..cfcf90e5f5 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
@@ -86,7 +86,7 @@ namespace osu.Game.Rulesets.Osu.Edit
defaultOrigin = OriginalSurroundingQuad.Value.Centre;
}
- public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both)
+ public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
{
if (!OperationInProgress.Value)
throw new InvalidOperationException($"Cannot {nameof(Update)} a scale operation without calling {nameof(Begin)} first!");
@@ -94,6 +94,7 @@ namespace osu.Game.Rulesets.Osu.Edit
Debug.Assert(objectsInScale != null && defaultOrigin != null && OriginalSurroundingQuad != null);
Vector2 actualOrigin = origin ?? defaultOrigin.Value;
+ scale = clampScaleToAdjustAxis(scale, adjustAxis);
// for the time being, allow resizing of slider paths only if the slider is
// the only hit object selected. with a group selection, it's likely the user
@@ -102,15 +103,15 @@ namespace osu.Game.Rulesets.Osu.Edit
{
var originalInfo = objectsInScale[slider];
Debug.Assert(originalInfo.PathControlPointPositions != null && originalInfo.PathControlPointTypes != null);
- scaleSlider(slider, scale, originalInfo.PathControlPointPositions, originalInfo.PathControlPointTypes);
+ scaleSlider(slider, scale, originalInfo.PathControlPointPositions, originalInfo.PathControlPointTypes, axisRotation);
}
else
{
- scale = ClampScaleToPlayfieldBounds(scale, actualOrigin);
+ scale = ClampScaleToPlayfieldBounds(scale, actualOrigin, adjustAxis, axisRotation);
foreach (var (ho, originalState) in objectsInScale)
{
- ho.Position = GeometryUtils.GetScaledPosition(scale, actualOrigin, originalState.Position);
+ ho.Position = GeometryUtils.GetScaledPosition(scale, actualOrigin, originalState.Position, axisRotation);
}
}
@@ -134,14 +135,34 @@ namespace osu.Game.Rulesets.Osu.Edit
private IEnumerable selectedMovableObjects => selectedItems.Cast()
.Where(h => h is not Spinner);
- private void scaleSlider(Slider slider, Vector2 scale, Vector2[] originalPathPositions, PathType?[] originalPathTypes)
+ private Vector2 clampScaleToAdjustAxis(Vector2 scale, Axes adjustAxis)
+ {
+ switch (adjustAxis)
+ {
+ case Axes.Y:
+ scale.X = 1;
+ break;
+
+ case Axes.X:
+ scale.Y = 1;
+ break;
+
+ case Axes.None:
+ scale = Vector2.One;
+ break;
+ }
+
+ return scale;
+ }
+
+ private void scaleSlider(Slider slider, Vector2 scale, Vector2[] originalPathPositions, PathType?[] originalPathTypes, float axisRotation = 0)
{
scale = Vector2.ComponentMax(scale, new Vector2(Precision.FLOAT_EPSILON));
// Maintain the path types in case they were defaulted to bezier at some point during scaling
for (int i = 0; i < slider.Path.ControlPoints.Count; i++)
{
- slider.Path.ControlPoints[i].Position = originalPathPositions[i] * scale;
+ slider.Path.ControlPoints[i].Position = GeometryUtils.GetScaledPosition(scale, Vector2.Zero, originalPathPositions[i], axisRotation);
slider.Path.ControlPoints[i].Type = originalPathTypes[i];
}
@@ -176,11 +197,13 @@ namespace osu.Game.Rulesets.Osu.Edit
///
/// The origin from which the scale operation is performed
/// The scale to be clamped
+ /// The axes to adjust the scale in.
+ /// The rotation of the axes in degrees
/// The clamped scale vector
- public Vector2 ClampScaleToPlayfieldBounds(Vector2 scale, Vector2? origin = null)
+ public Vector2 ClampScaleToPlayfieldBounds(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
{
//todo: this is not always correct for selections involving sliders. This approximation assumes each point is scaled independently, but sliderends move with the sliderhead.
- if (objectsInScale == null)
+ if (objectsInScale == null || adjustAxis == Axes.None)
return scale;
Debug.Assert(defaultOrigin != null && OriginalSurroundingQuad != null);
@@ -188,24 +211,63 @@ namespace osu.Game.Rulesets.Osu.Edit
if (objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider)
origin = slider.Position;
+ scale = clampScaleToAdjustAxis(scale, adjustAxis);
Vector2 actualOrigin = origin ?? defaultOrigin.Value;
var selectionQuad = OriginalSurroundingQuad.Value;
- var tl1 = Vector2.Divide(-actualOrigin, selectionQuad.TopLeft - actualOrigin);
- var tl2 = Vector2.Divide(OsuPlayfield.BASE_SIZE - actualOrigin, selectionQuad.TopLeft - actualOrigin);
- var br1 = Vector2.Divide(-actualOrigin, selectionQuad.BottomRight - actualOrigin);
- var br2 = Vector2.Divide(OsuPlayfield.BASE_SIZE - actualOrigin, selectionQuad.BottomRight - actualOrigin);
-
- if (!Precision.AlmostEquals(selectionQuad.TopLeft.X - actualOrigin.X, 0))
- scale.X = selectionQuad.TopLeft.X - actualOrigin.X < 0 ? MathHelper.Clamp(scale.X, tl2.X, tl1.X) : MathHelper.Clamp(scale.X, tl1.X, tl2.X);
- if (!Precision.AlmostEquals(selectionQuad.TopLeft.Y - actualOrigin.Y, 0))
- scale.Y = selectionQuad.TopLeft.Y - actualOrigin.Y < 0 ? MathHelper.Clamp(scale.Y, tl2.Y, tl1.Y) : MathHelper.Clamp(scale.Y, tl1.Y, tl2.Y);
- if (!Precision.AlmostEquals(selectionQuad.BottomRight.X - actualOrigin.X, 0))
- scale.X = selectionQuad.BottomRight.X - actualOrigin.X < 0 ? MathHelper.Clamp(scale.X, br2.X, br1.X) : MathHelper.Clamp(scale.X, br1.X, br2.X);
- if (!Precision.AlmostEquals(selectionQuad.BottomRight.Y - actualOrigin.Y, 0))
- scale.Y = selectionQuad.BottomRight.Y - actualOrigin.Y < 0 ? MathHelper.Clamp(scale.Y, br2.Y, br1.Y) : MathHelper.Clamp(scale.Y, br1.Y, br2.Y);
+ scale = clampToBound(scale, selectionQuad.BottomRight, OsuPlayfield.BASE_SIZE.X, Axes.X);
+ scale = clampToBound(scale, selectionQuad.BottomRight, OsuPlayfield.BASE_SIZE.Y, Axes.Y);
+ scale = clampToBound(scale, selectionQuad.TopLeft, 0, Axes.X);
+ scale = clampToBound(scale, selectionQuad.TopLeft, 0, Axes.Y);
return Vector2.ComponentMax(scale, new Vector2(Precision.FLOAT_EPSILON));
+
+ Vector2 clampToBound(Vector2 s, Vector2 p, float bound, Axes axis)
+ {
+ float px = p.X - actualOrigin.X;
+ float py = p.Y - actualOrigin.Y;
+ float c = axis == Axes.X ? bound - actualOrigin.X : bound - actualOrigin.Y;
+ float cos = MathF.Cos(float.DegreesToRadians(-axisRotation));
+ float sin = MathF.Sin(float.DegreesToRadians(-axisRotation));
+ float a, b;
+
+ if (axis == Axes.X)
+ {
+ a = cos * cos * px - sin * cos * py;
+ b = sin * sin * px + sin * cos * py;
+ }
+ else
+ {
+ a = -sin * cos * px + sin * sin * py;
+ b = sin * cos * px + cos * cos * py;
+ }
+
+ switch (adjustAxis)
+ {
+ case Axes.X:
+ if (Precision.AlmostEquals(a, 0) || (c - b) / a < 0)
+ break;
+
+ s.X = MathF.Min(scale.X, (c - b) / a);
+ break;
+
+ case Axes.Y:
+ if (Precision.AlmostEquals(b, 0) || (c - a) / b < 0)
+ break;
+
+ s.Y = MathF.Min(scale.Y, (c - a) / b);
+ break;
+
+ case Axes.Both:
+ if (Precision.AlmostEquals(a + b, 0) || c / (a * s.X + b * s.Y) < 0)
+ break;
+
+ s = Vector2.ComponentMin(s, s * c / (a * s.X + b * s.Y));
+ break;
+ }
+
+ return s;
+ }
}
private void moveSelectionInBounds()
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
index 65a07e2e2f..a1907a2fd5 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
@@ -130,8 +130,8 @@ namespace osu.Game.Rulesets.Osu.Edit
scaleInfo.BindValueChanged(scale =>
{
- var newScale = new Vector2(scale.NewValue.XAxis ? scale.NewValue.Scale : 1, scale.NewValue.YAxis ? scale.NewValue.Scale : 1);
- scaleHandler.Update(newScale, getOriginPosition(scale.NewValue));
+ var newScale = new Vector2(scale.NewValue.Scale, scale.NewValue.Scale);
+ scaleHandler.Update(newScale, getOriginPosition(scale.NewValue), getAdjustAxis(scale.NewValue), gridToolbox.GridLinesRotation.Value);
});
}
@@ -164,7 +164,7 @@ namespace osu.Game.Rulesets.Osu.Edit
return;
const float max_scale = 10;
- var scale = scaleHandler.ClampScaleToPlayfieldBounds(new Vector2(max_scale), getOriginPosition(scaleInfo.Value));
+ var scale = scaleHandler.ClampScaleToPlayfieldBounds(new Vector2(max_scale), getOriginPosition(scaleInfo.Value), getAdjustAxis(scaleInfo.Value), gridToolbox.GridLinesRotation.Value);
if (!scaleInfo.Value.XAxis)
scale.X = max_scale;
@@ -183,6 +183,8 @@ namespace osu.Game.Rulesets.Osu.Edit
private Vector2? getOriginPosition(PreciseScaleInfo scale) => scale.Origin == ScaleOrigin.PlayfieldCentre ? gridToolbox.StartPosition.Value : null;
+ private Axes getAdjustAxis(PreciseScaleInfo scale) => scale.XAxis ? scale.YAxis ? Axes.Both : Axes.X : Axes.Y;
+
private void setAxis(bool x, bool y)
{
scaleInfo.Value = scaleInfo.Value with { XAxis = x, YAxis = y };
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs b/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
index 28763051e3..30f397f518 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneComposeSelectBox.cs
@@ -134,7 +134,7 @@ namespace osu.Game.Tests.Visual.Editing
OriginalSurroundingQuad = new Quad(targetContainer!.X, targetContainer.Y, targetContainer.Width, targetContainer.Height);
}
- public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both)
+ public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
{
if (targetContainer == null)
throw new InvalidOperationException($"Cannot {nameof(Update)} a scale operation without calling {nameof(Begin)} first!");
diff --git a/osu.Game/Overlays/SkinEditor/SkinSelectionScaleHandler.cs b/osu.Game/Overlays/SkinEditor/SkinSelectionScaleHandler.cs
index 4bfa7fba81..977aaade99 100644
--- a/osu.Game/Overlays/SkinEditor/SkinSelectionScaleHandler.cs
+++ b/osu.Game/Overlays/SkinEditor/SkinSelectionScaleHandler.cs
@@ -73,7 +73,7 @@ namespace osu.Game.Overlays.SkinEditor
isFlippedY = false;
}
- public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both)
+ public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
{
if (objectsInScale == null)
throw new InvalidOperationException($"Cannot {nameof(Update)} a scale operation without calling {nameof(Begin)} first!");
diff --git a/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs b/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs
index c91362219c..177de9df33 100644
--- a/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/SelectionScaleHandler.cs
@@ -52,10 +52,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
/// If the default value is supplied, a sane implementation-defined default will be used.
///
/// The axes to adjust the scale in.
- public void ScaleSelection(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both)
+ /// The rotation of the axes in degrees.
+ public void ScaleSelection(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
{
Begin();
- Update(scale, origin, adjustAxis);
+ Update(scale, origin, adjustAxis, axisRotation);
Commit();
}
@@ -91,7 +92,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
/// If the default value is supplied, a sane implementation-defined default will be used.
///
/// The axes to adjust the scale in.
- public virtual void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both)
+ /// The rotation of the axes in degrees.
+ public virtual void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
{
}
diff --git a/osu.Game/Utils/GeometryUtils.cs b/osu.Game/Utils/GeometryUtils.cs
index bf1addf6c8..f6e7e81007 100644
--- a/osu.Game/Utils/GeometryUtils.cs
+++ b/osu.Game/Utils/GeometryUtils.cs
@@ -104,9 +104,9 @@ namespace osu.Game.Utils
/// Given a scale multiplier, an origin, and a position,
/// will return the scaled position in screen space coordinates.
///
- public static Vector2 GetScaledPosition(Vector2 scale, Vector2 origin, Vector2 position)
+ public static Vector2 GetScaledPosition(Vector2 scale, Vector2 origin, Vector2 position, float axisRotation = 0)
{
- return origin + (position - origin) * scale;
+ return origin + RotateVector(RotateVector(position - origin, axisRotation) * scale, -axisRotation);
}
///
From 979a5e9f3e5de341bcfe785ca7978f5449e0fd78 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Wed, 3 Jul 2024 16:41:41 +0200
Subject: [PATCH 117/924] simplify code
---
.../Edit/OsuSelectionScaleHandler.cs | 46 ++++++-------------
1 file changed, 13 insertions(+), 33 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
index cfcf90e5f5..2cf5a604ed 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
@@ -194,7 +194,7 @@ namespace osu.Game.Rulesets.Osu.Edit
///
/// Clamp scale for multi-object-scaling where selection does not exceed playfield bounds or flip.
- ///
+ /// The origin from which the scale operation is performed
/// The scale to be clamped
/// The axes to adjust the scale in.
@@ -215,54 +215,34 @@ namespace osu.Game.Rulesets.Osu.Edit
Vector2 actualOrigin = origin ?? defaultOrigin.Value;
var selectionQuad = OriginalSurroundingQuad.Value;
- scale = clampToBound(scale, selectionQuad.BottomRight, OsuPlayfield.BASE_SIZE.X, Axes.X);
- scale = clampToBound(scale, selectionQuad.BottomRight, OsuPlayfield.BASE_SIZE.Y, Axes.Y);
- scale = clampToBound(scale, selectionQuad.TopLeft, 0, Axes.X);
- scale = clampToBound(scale, selectionQuad.TopLeft, 0, Axes.Y);
+ scale = clampToBound(scale, selectionQuad.BottomRight, OsuPlayfield.BASE_SIZE);
+ scale = clampToBound(scale, selectionQuad.TopLeft, Vector2.Zero);
return Vector2.ComponentMax(scale, new Vector2(Precision.FLOAT_EPSILON));
- Vector2 clampToBound(Vector2 s, Vector2 p, float bound, Axes axis)
+ float minPositiveComponent(Vector2 v) => MathF.Min(v.X < 0 ? float.PositiveInfinity : v.X, v.Y < 0 ? float.PositiveInfinity : v.Y);
+
+ Vector2 clampToBound(Vector2 s, Vector2 p, Vector2 bound)
{
- float px = p.X - actualOrigin.X;
- float py = p.Y - actualOrigin.Y;
- float c = axis == Axes.X ? bound - actualOrigin.X : bound - actualOrigin.Y;
+ p -= actualOrigin;
+ bound -= actualOrigin;
float cos = MathF.Cos(float.DegreesToRadians(-axisRotation));
float sin = MathF.Sin(float.DegreesToRadians(-axisRotation));
- float a, b;
-
- if (axis == Axes.X)
- {
- a = cos * cos * px - sin * cos * py;
- b = sin * sin * px + sin * cos * py;
- }
- else
- {
- a = -sin * cos * px + sin * sin * py;
- b = sin * cos * px + cos * cos * py;
- }
+ var a = new Vector2(cos * cos * p.X - sin * cos * p.Y, -sin * cos * p.X + sin * sin * p.Y);
+ var b = new Vector2(sin * sin * p.X + sin * cos * p.Y, sin * cos * p.X + cos * cos * p.Y);
switch (adjustAxis)
{
case Axes.X:
- if (Precision.AlmostEquals(a, 0) || (c - b) / a < 0)
- break;
-
- s.X = MathF.Min(scale.X, (c - b) / a);
+ s.X = MathF.Min(scale.X, minPositiveComponent(Vector2.Divide(bound - b, a)));
break;
case Axes.Y:
- if (Precision.AlmostEquals(b, 0) || (c - a) / b < 0)
- break;
-
- s.Y = MathF.Min(scale.Y, (c - a) / b);
+ s.Y = MathF.Min(scale.Y, minPositiveComponent(Vector2.Divide(bound - a, b)));
break;
case Axes.Both:
- if (Precision.AlmostEquals(a + b, 0) || c / (a * s.X + b * s.Y) < 0)
- break;
-
- s = Vector2.ComponentMin(s, s * c / (a * s.X + b * s.Y));
+ s = Vector2.ComponentMin(s, s * minPositiveComponent(Vector2.Divide(bound, a * s.X + b * s.Y)));
break;
}
From 0797d942aecde4e267fca11fbec5bf73611fc9b8 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Wed, 3 Jul 2024 16:41:57 +0200
Subject: [PATCH 118/924] fix warning
---
osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
index 2cf5a604ed..8b87246456 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
@@ -194,7 +194,7 @@ namespace osu.Game.Rulesets.Osu.Edit
///
/// Clamp scale for multi-object-scaling where selection does not exceed playfield bounds or flip.
- ///
/// The origin from which the scale operation is performed
/// The scale to be clamped
/// The axes to adjust the scale in.
From 4165ded8134d05f4d6b934255a5678a6a7d74bca Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Wed, 3 Jul 2024 19:03:15 +0200
Subject: [PATCH 119/924] fix incorrect rotated bound checking
---
.../Edit/OsuSelectionScaleHandler.cs | 53 +++++++++++++++----
osu.Game/Utils/GeometryUtils.cs | 20 ++++---
2 files changed, 56 insertions(+), 17 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
index 8b87246456..d336261499 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
@@ -80,12 +80,32 @@ namespace osu.Game.Rulesets.Osu.Edit
changeHandler?.BeginChange();
objectsInScale = selectedMovableObjects.ToDictionary(ho => ho, ho => new OriginalHitObjectState(ho));
- OriginalSurroundingQuad = objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider
- ? GeometryUtils.GetSurroundingQuad(slider.Path.ControlPoints.Select(p => slider.Position + p.Position))
- : GeometryUtils.GetSurroundingQuad(objectsInScale.Keys);
+ OriginalSurroundingQuad = getOriginalSurroundingQuad()!;
defaultOrigin = OriginalSurroundingQuad.Value.Centre;
}
+ private Quad? getOriginalSurroundingQuad(float axisRotation = 0)
+ {
+ if (objectsInScale == null)
+ return null;
+
+ return objectsInScale.Count == 1 && objectsInScale.First().Value.PathControlPointPositions != null
+ ? GeometryUtils.GetSurroundingQuad(objectsInScale.First().Value.PathControlPointPositions!.Select(p => objectsInScale.First().Value.Position + p), axisRotation)
+ : GeometryUtils.GetSurroundingQuad(objectsInScale.Values.SelectMany(s =>
+ {
+ if (s.EndPosition.HasValue)
+ {
+ return new[]
+ {
+ s.Position,
+ s.Position + s.EndPosition.Value
+ };
+ }
+
+ return new[] { s.Position };
+ }), axisRotation);
+ }
+
public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
{
if (!OperationInProgress.Value)
@@ -213,10 +233,23 @@ namespace osu.Game.Rulesets.Osu.Edit
scale = clampScaleToAdjustAxis(scale, adjustAxis);
Vector2 actualOrigin = origin ?? defaultOrigin.Value;
- var selectionQuad = OriginalSurroundingQuad.Value;
+ var selectionQuad = axisRotation == 0 ? OriginalSurroundingQuad.Value : getOriginalSurroundingQuad(axisRotation)!.Value;
+ var points = new[]
+ {
+ selectionQuad.TopLeft,
+ selectionQuad.TopRight,
+ selectionQuad.BottomLeft,
+ selectionQuad.BottomRight
+ };
- scale = clampToBound(scale, selectionQuad.BottomRight, OsuPlayfield.BASE_SIZE);
- scale = clampToBound(scale, selectionQuad.TopLeft, Vector2.Zero);
+ float cos = MathF.Cos(float.DegreesToRadians(-axisRotation));
+ float sin = MathF.Sin(float.DegreesToRadians(-axisRotation));
+
+ foreach (var point in points)
+ {
+ scale = clampToBound(scale, point, Vector2.Zero);
+ scale = clampToBound(scale, point, OsuPlayfield.BASE_SIZE);
+ }
return Vector2.ComponentMax(scale, new Vector2(Precision.FLOAT_EPSILON));
@@ -226,19 +259,17 @@ namespace osu.Game.Rulesets.Osu.Edit
{
p -= actualOrigin;
bound -= actualOrigin;
- float cos = MathF.Cos(float.DegreesToRadians(-axisRotation));
- float sin = MathF.Sin(float.DegreesToRadians(-axisRotation));
var a = new Vector2(cos * cos * p.X - sin * cos * p.Y, -sin * cos * p.X + sin * sin * p.Y);
var b = new Vector2(sin * sin * p.X + sin * cos * p.Y, sin * cos * p.X + cos * cos * p.Y);
switch (adjustAxis)
{
case Axes.X:
- s.X = MathF.Min(scale.X, minPositiveComponent(Vector2.Divide(bound - b, a)));
+ s.X = MathF.Min(s.X, minPositiveComponent(Vector2.Divide(bound - b, a)));
break;
case Axes.Y:
- s.Y = MathF.Min(scale.Y, minPositiveComponent(Vector2.Divide(bound - a, b)));
+ s.Y = MathF.Min(s.Y, minPositiveComponent(Vector2.Divide(bound - a, b)));
break;
case Axes.Both:
@@ -275,12 +306,14 @@ namespace osu.Game.Rulesets.Osu.Edit
public Vector2 Position { get; }
public Vector2[]? PathControlPointPositions { get; }
public PathType?[]? PathControlPointTypes { get; }
+ public Vector2? EndPosition { get; }
public OriginalHitObjectState(OsuHitObject hitObject)
{
Position = hitObject.Position;
PathControlPointPositions = (hitObject as IHasPath)?.Path.ControlPoints.Select(p => p.Position).ToArray();
PathControlPointTypes = (hitObject as IHasPath)?.Path.ControlPoints.Select(p => p.Type).ToArray();
+ EndPosition = (hitObject as IHasPath)?.Path.PositionAt(1);
}
}
}
diff --git a/osu.Game/Utils/GeometryUtils.cs b/osu.Game/Utils/GeometryUtils.cs
index f6e7e81007..23c25cfffa 100644
--- a/osu.Game/Utils/GeometryUtils.cs
+++ b/osu.Game/Utils/GeometryUtils.cs
@@ -113,7 +113,8 @@ namespace osu.Game.Utils
/// Returns a quad surrounding the provided points.
///
/// The points to calculate a quad for.
- public static Quad GetSurroundingQuad(IEnumerable points)
+ /// The rotation in degrees of the axis to align the quad to.
+ public static Quad GetSurroundingQuad(IEnumerable points, float axisRotation = 0)
{
if (!points.Any())
return new Quad();
@@ -124,20 +125,25 @@ namespace osu.Game.Utils
// Go through all hitobjects to make sure they would remain in the bounds of the editor after movement, before any movement is attempted
foreach (var p in points)
{
- minPosition = Vector2.ComponentMin(minPosition, p);
- maxPosition = Vector2.ComponentMax(maxPosition, p);
+ var pr = RotateVector(p, axisRotation);
+ minPosition = Vector2.ComponentMin(minPosition, pr);
+ maxPosition = Vector2.ComponentMax(maxPosition, pr);
}
- Vector2 size = maxPosition - minPosition;
+ var p1 = RotateVector(minPosition, -axisRotation);
+ var p2 = RotateVector(new Vector2(minPosition.X, maxPosition.Y), -axisRotation);
+ var p3 = RotateVector(maxPosition, -axisRotation);
+ var p4 = RotateVector(new Vector2(maxPosition.X, minPosition.Y), -axisRotation);
- return new Quad(minPosition.X, minPosition.Y, size.X, size.Y);
+ return new Quad(p1, p2, p3, p4);
}
///
/// Returns a gamefield-space quad surrounding the provided hit objects.
///
/// The hit objects to calculate a quad for.
- public static Quad GetSurroundingQuad(IEnumerable hitObjects) =>
+ /// The rotation in degrees of the axis to align the quad to.
+ public static Quad GetSurroundingQuad(IEnumerable hitObjects, float axisRotation = 0) =>
GetSurroundingQuad(hitObjects.SelectMany(h =>
{
if (h is IHasPath path)
@@ -151,6 +157,6 @@ namespace osu.Game.Utils
}
return new[] { h.Position };
- }));
+ }), axisRotation);
}
}
From dfe6c70996b06fa0e597fffbf1aec75e5b1d508c Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Wed, 3 Jul 2024 19:08:31 +0200
Subject: [PATCH 120/924] prevent flipping objects far offscreen
---
osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
index 7720afe60a..7d6ef66909 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
@@ -15,6 +15,7 @@ using osu.Game.Rulesets.Edit;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Objects.Types;
using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.UI;
using osu.Game.Screens.Edit.Compose.Components;
using osu.Game.Utils;
using osuTK;
@@ -119,6 +120,9 @@ namespace osu.Game.Rulesets.Osu.Edit
{
var flippedPosition = GeometryUtils.GetFlippedPosition(flipAxis, flipQuad, h.Position);
+ // Clamp the flipped position inside the playfield bounds, because the flipped position might be outside the playfield bounds if the origin is not centered.
+ flippedPosition = Vector2.Clamp(flippedPosition, Vector2.Zero, OsuPlayfield.BASE_SIZE);
+
if (!Precision.AlmostEquals(flippedPosition, h.Position))
{
h.Position = flippedPosition;
From ae380027772867b45baf80acc910c98cb39fac46 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 15:46:40 +0200
Subject: [PATCH 121/924] Revert "fix incorrect rotated bound checking"
This reverts commit 4165ded8134d05f4d6b934255a5678a6a7d74bca.
---
.../Edit/OsuSelectionScaleHandler.cs | 53 ++++---------------
osu.Game/Utils/GeometryUtils.cs | 20 +++----
2 files changed, 17 insertions(+), 56 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
index d336261499..8b87246456 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
@@ -80,32 +80,12 @@ namespace osu.Game.Rulesets.Osu.Edit
changeHandler?.BeginChange();
objectsInScale = selectedMovableObjects.ToDictionary(ho => ho, ho => new OriginalHitObjectState(ho));
- OriginalSurroundingQuad = getOriginalSurroundingQuad()!;
+ OriginalSurroundingQuad = objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider
+ ? GeometryUtils.GetSurroundingQuad(slider.Path.ControlPoints.Select(p => slider.Position + p.Position))
+ : GeometryUtils.GetSurroundingQuad(objectsInScale.Keys);
defaultOrigin = OriginalSurroundingQuad.Value.Centre;
}
- private Quad? getOriginalSurroundingQuad(float axisRotation = 0)
- {
- if (objectsInScale == null)
- return null;
-
- return objectsInScale.Count == 1 && objectsInScale.First().Value.PathControlPointPositions != null
- ? GeometryUtils.GetSurroundingQuad(objectsInScale.First().Value.PathControlPointPositions!.Select(p => objectsInScale.First().Value.Position + p), axisRotation)
- : GeometryUtils.GetSurroundingQuad(objectsInScale.Values.SelectMany(s =>
- {
- if (s.EndPosition.HasValue)
- {
- return new[]
- {
- s.Position,
- s.Position + s.EndPosition.Value
- };
- }
-
- return new[] { s.Position };
- }), axisRotation);
- }
-
public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
{
if (!OperationInProgress.Value)
@@ -233,23 +213,10 @@ namespace osu.Game.Rulesets.Osu.Edit
scale = clampScaleToAdjustAxis(scale, adjustAxis);
Vector2 actualOrigin = origin ?? defaultOrigin.Value;
- var selectionQuad = axisRotation == 0 ? OriginalSurroundingQuad.Value : getOriginalSurroundingQuad(axisRotation)!.Value;
- var points = new[]
- {
- selectionQuad.TopLeft,
- selectionQuad.TopRight,
- selectionQuad.BottomLeft,
- selectionQuad.BottomRight
- };
+ var selectionQuad = OriginalSurroundingQuad.Value;
- float cos = MathF.Cos(float.DegreesToRadians(-axisRotation));
- float sin = MathF.Sin(float.DegreesToRadians(-axisRotation));
-
- foreach (var point in points)
- {
- scale = clampToBound(scale, point, Vector2.Zero);
- scale = clampToBound(scale, point, OsuPlayfield.BASE_SIZE);
- }
+ scale = clampToBound(scale, selectionQuad.BottomRight, OsuPlayfield.BASE_SIZE);
+ scale = clampToBound(scale, selectionQuad.TopLeft, Vector2.Zero);
return Vector2.ComponentMax(scale, new Vector2(Precision.FLOAT_EPSILON));
@@ -259,17 +226,19 @@ namespace osu.Game.Rulesets.Osu.Edit
{
p -= actualOrigin;
bound -= actualOrigin;
+ float cos = MathF.Cos(float.DegreesToRadians(-axisRotation));
+ float sin = MathF.Sin(float.DegreesToRadians(-axisRotation));
var a = new Vector2(cos * cos * p.X - sin * cos * p.Y, -sin * cos * p.X + sin * sin * p.Y);
var b = new Vector2(sin * sin * p.X + sin * cos * p.Y, sin * cos * p.X + cos * cos * p.Y);
switch (adjustAxis)
{
case Axes.X:
- s.X = MathF.Min(s.X, minPositiveComponent(Vector2.Divide(bound - b, a)));
+ s.X = MathF.Min(scale.X, minPositiveComponent(Vector2.Divide(bound - b, a)));
break;
case Axes.Y:
- s.Y = MathF.Min(s.Y, minPositiveComponent(Vector2.Divide(bound - a, b)));
+ s.Y = MathF.Min(scale.Y, minPositiveComponent(Vector2.Divide(bound - a, b)));
break;
case Axes.Both:
@@ -306,14 +275,12 @@ namespace osu.Game.Rulesets.Osu.Edit
public Vector2 Position { get; }
public Vector2[]? PathControlPointPositions { get; }
public PathType?[]? PathControlPointTypes { get; }
- public Vector2? EndPosition { get; }
public OriginalHitObjectState(OsuHitObject hitObject)
{
Position = hitObject.Position;
PathControlPointPositions = (hitObject as IHasPath)?.Path.ControlPoints.Select(p => p.Position).ToArray();
PathControlPointTypes = (hitObject as IHasPath)?.Path.ControlPoints.Select(p => p.Type).ToArray();
- EndPosition = (hitObject as IHasPath)?.Path.PositionAt(1);
}
}
}
diff --git a/osu.Game/Utils/GeometryUtils.cs b/osu.Game/Utils/GeometryUtils.cs
index 23c25cfffa..f6e7e81007 100644
--- a/osu.Game/Utils/GeometryUtils.cs
+++ b/osu.Game/Utils/GeometryUtils.cs
@@ -113,8 +113,7 @@ namespace osu.Game.Utils
/// Returns a quad surrounding the provided points.
///
/// The points to calculate a quad for.
- /// The rotation in degrees of the axis to align the quad to.
- public static Quad GetSurroundingQuad(IEnumerable points, float axisRotation = 0)
+ public static Quad GetSurroundingQuad(IEnumerable points)
{
if (!points.Any())
return new Quad();
@@ -125,25 +124,20 @@ namespace osu.Game.Utils
// Go through all hitobjects to make sure they would remain in the bounds of the editor after movement, before any movement is attempted
foreach (var p in points)
{
- var pr = RotateVector(p, axisRotation);
- minPosition = Vector2.ComponentMin(minPosition, pr);
- maxPosition = Vector2.ComponentMax(maxPosition, pr);
+ minPosition = Vector2.ComponentMin(minPosition, p);
+ maxPosition = Vector2.ComponentMax(maxPosition, p);
}
- var p1 = RotateVector(minPosition, -axisRotation);
- var p2 = RotateVector(new Vector2(minPosition.X, maxPosition.Y), -axisRotation);
- var p3 = RotateVector(maxPosition, -axisRotation);
- var p4 = RotateVector(new Vector2(maxPosition.X, minPosition.Y), -axisRotation);
+ Vector2 size = maxPosition - minPosition;
- return new Quad(p1, p2, p3, p4);
+ return new Quad(minPosition.X, minPosition.Y, size.X, size.Y);
}
///
/// Returns a gamefield-space quad surrounding the provided hit objects.
///
/// The hit objects to calculate a quad for.
- /// The rotation in degrees of the axis to align the quad to.
- public static Quad GetSurroundingQuad(IEnumerable hitObjects, float axisRotation = 0) =>
+ public static Quad GetSurroundingQuad(IEnumerable hitObjects) =>
GetSurroundingQuad(hitObjects.SelectMany(h =>
{
if (h is IHasPath path)
@@ -157,6 +151,6 @@ namespace osu.Game.Utils
}
return new[] { h.Position };
- }), axisRotation);
+ }));
}
}
From 58eb7f6fe174ba72f06304d0334b0668dde14c74 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 16:58:05 +0200
Subject: [PATCH 122/924] fix rotated scale bounds again
---
.../Edit/OsuSelectionScaleHandler.cs | 31 ++++++++++--
osu.Game/Utils/GeometryUtils.cs | 49 ++++++++++++++++++-
2 files changed, 73 insertions(+), 7 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
index 8b87246456..56c3ba9315 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionScaleHandler.cs
@@ -69,6 +69,7 @@ namespace osu.Game.Rulesets.Osu.Edit
private Dictionary? objectsInScale;
private Vector2? defaultOrigin;
+ private List? originalConvexHull;
public override void Begin()
{
@@ -84,6 +85,9 @@ namespace osu.Game.Rulesets.Osu.Edit
? GeometryUtils.GetSurroundingQuad(slider.Path.ControlPoints.Select(p => slider.Position + p.Position))
: GeometryUtils.GetSurroundingQuad(objectsInScale.Keys);
defaultOrigin = OriginalSurroundingQuad.Value.Centre;
+ originalConvexHull = objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider2
+ ? GeometryUtils.GetConvexHull(slider2.Path.ControlPoints.Select(p => slider2.Position + p.Position))
+ : GeometryUtils.GetConvexHull(objectsInScale.Keys);
}
public override void Update(Vector2 scale, Vector2? origin = null, Axes adjustAxis = Axes.Both, float axisRotation = 0)
@@ -211,12 +215,31 @@ namespace osu.Game.Rulesets.Osu.Edit
if (objectsInScale.Count == 1 && objectsInScale.First().Key is Slider slider)
origin = slider.Position;
+ float cos = MathF.Cos(float.DegreesToRadians(-axisRotation));
+ float sin = MathF.Sin(float.DegreesToRadians(-axisRotation));
scale = clampScaleToAdjustAxis(scale, adjustAxis);
Vector2 actualOrigin = origin ?? defaultOrigin.Value;
- var selectionQuad = OriginalSurroundingQuad.Value;
+ IEnumerable points;
- scale = clampToBound(scale, selectionQuad.BottomRight, OsuPlayfield.BASE_SIZE);
- scale = clampToBound(scale, selectionQuad.TopLeft, Vector2.Zero);
+ if (axisRotation == 0)
+ {
+ var selectionQuad = OriginalSurroundingQuad.Value;
+ points = new[]
+ {
+ selectionQuad.TopLeft,
+ selectionQuad.TopRight,
+ selectionQuad.BottomLeft,
+ selectionQuad.BottomRight
+ };
+ }
+ else
+ points = originalConvexHull!;
+
+ foreach (var point in points)
+ {
+ scale = clampToBound(scale, point, Vector2.Zero);
+ scale = clampToBound(scale, point, OsuPlayfield.BASE_SIZE);
+ }
return Vector2.ComponentMax(scale, new Vector2(Precision.FLOAT_EPSILON));
@@ -226,8 +249,6 @@ namespace osu.Game.Rulesets.Osu.Edit
{
p -= actualOrigin;
bound -= actualOrigin;
- float cos = MathF.Cos(float.DegreesToRadians(-axisRotation));
- float sin = MathF.Sin(float.DegreesToRadians(-axisRotation));
var a = new Vector2(cos * cos * p.X - sin * cos * p.Y, -sin * cos * p.X + sin * sin * p.Y);
var b = new Vector2(sin * sin * p.X + sin * cos * p.Y, sin * cos * p.X + cos * cos * p.Y);
diff --git a/osu.Game/Utils/GeometryUtils.cs b/osu.Game/Utils/GeometryUtils.cs
index f6e7e81007..5a8ca9722e 100644
--- a/osu.Game/Utils/GeometryUtils.cs
+++ b/osu.Game/Utils/GeometryUtils.cs
@@ -138,7 +138,52 @@ namespace osu.Game.Utils
///
/// The hit objects to calculate a quad for.
public static Quad GetSurroundingQuad(IEnumerable hitObjects) =>
- GetSurroundingQuad(hitObjects.SelectMany(h =>
+ GetSurroundingQuad(enumerateStartAndEndPositions(hitObjects));
+
+ ///
+ /// Returns the points that make up the convex hull of the provided points.
+ ///
+ /// The points to calculate a convex hull.
+ public static List GetConvexHull(IEnumerable points)
+ {
+ List p = points.ToList();
+
+ if (p.Count <= 1)
+ return p;
+
+ int n = p.Count, k = 0;
+ List hull = new List(new Vector2[2 * n]);
+
+ p.Sort((a, b) => a.X == b.X ? a.Y.CompareTo(b.Y) : a.X.CompareTo(b.X));
+
+ // Build lower hull
+ for (int i = 0; i < n; ++i)
+ {
+ while (k >= 2 && cross(hull[k - 2], hull[k - 1], p[i]) <= 0)
+ k--;
+ hull[k] = p[i];
+ k++;
+ }
+
+ // Build upper hull
+ for (int i = n - 2, t = k + 1; i >= 0; i--)
+ {
+ while (k >= t && cross(hull[k - 2], hull[k - 1], p[i]) <= 0)
+ k--;
+ hull[k] = p[i];
+ k++;
+ }
+
+ return hull.Take(k - 1).ToList();
+
+ float cross(Vector2 o, Vector2 a, Vector2 b) => (a.X - o.X) * (b.Y - o.Y) - (a.Y - o.Y) * (b.X - o.X);
+ }
+
+ public static List GetConvexHull(IEnumerable hitObjects) =>
+ GetConvexHull(enumerateStartAndEndPositions(hitObjects));
+
+ private static IEnumerable enumerateStartAndEndPositions(IEnumerable hitObjects) =>
+ hitObjects.SelectMany(h =>
{
if (h is IHasPath path)
{
@@ -151,6 +196,6 @@ namespace osu.Game.Utils
}
return new[] { h.Position };
- }));
+ });
}
}
From 7a319a6d74ee29fbf3e7b5dbc2b7c6c9ca8e4990 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 17:03:17 +0200
Subject: [PATCH 123/924] dont rotate scale when in selection origin mode
---
osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
index a1907a2fd5..0f04efcfa5 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
@@ -131,7 +131,7 @@ namespace osu.Game.Rulesets.Osu.Edit
scaleInfo.BindValueChanged(scale =>
{
var newScale = new Vector2(scale.NewValue.Scale, scale.NewValue.Scale);
- scaleHandler.Update(newScale, getOriginPosition(scale.NewValue), getAdjustAxis(scale.NewValue), gridToolbox.GridLinesRotation.Value);
+ scaleHandler.Update(newScale, getOriginPosition(scale.NewValue), getAdjustAxis(scale.NewValue), getRotation(scale.NewValue));
});
}
@@ -164,7 +164,7 @@ namespace osu.Game.Rulesets.Osu.Edit
return;
const float max_scale = 10;
- var scale = scaleHandler.ClampScaleToPlayfieldBounds(new Vector2(max_scale), getOriginPosition(scaleInfo.Value), getAdjustAxis(scaleInfo.Value), gridToolbox.GridLinesRotation.Value);
+ var scale = scaleHandler.ClampScaleToPlayfieldBounds(new Vector2(max_scale), getOriginPosition(scaleInfo.Value), getAdjustAxis(scaleInfo.Value), getRotation(scaleInfo.Value));
if (!scaleInfo.Value.XAxis)
scale.X = max_scale;
@@ -185,6 +185,8 @@ namespace osu.Game.Rulesets.Osu.Edit
private Axes getAdjustAxis(PreciseScaleInfo scale) => scale.XAxis ? scale.YAxis ? Axes.Both : Axes.X : Axes.Y;
+ private float getRotation(PreciseScaleInfo scale) => scale.Origin == ScaleOrigin.PlayfieldCentre ? gridToolbox.GridLinesRotation.Value : 0;
+
private void setAxis(bool x, bool y)
{
scaleInfo.Value = scaleInfo.Value with { XAxis = x, YAxis = y };
From 9e5d099b1b1113304294c17155f42ab4a8ea76cd Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 17:13:22 +0200
Subject: [PATCH 124/924] rename playfield centre origin to grid centre
---
.../Edit/PreciseRotationPopover.cs | 12 ++++++------
.../Edit/PreciseScalePopover.cs | 16 ++++++++--------
2 files changed, 14 insertions(+), 14 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
index 6a3e326c2b..4a1ccc4b61 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
@@ -20,7 +20,7 @@ namespace osu.Game.Rulesets.Osu.Edit
private readonly OsuGridToolboxGroup gridToolbox;
- private readonly Bindable rotationInfo = new Bindable(new PreciseRotationInfo(0, RotationOrigin.PlayfieldCentre));
+ private readonly Bindable rotationInfo = new Bindable(new PreciseRotationInfo(0, RotationOrigin.GridCentre));
private SliderWithTextBoxInput angleInput = null!;
private EditorRadioButtonCollection rotationOrigin = null!;
@@ -60,9 +60,9 @@ namespace osu.Game.Rulesets.Osu.Edit
RelativeSizeAxes = Axes.X,
Items = new[]
{
- new RadioButton("Playfield centre",
- () => rotationInfo.Value = rotationInfo.Value with { Origin = RotationOrigin.PlayfieldCentre },
- () => new SpriteIcon { Icon = FontAwesome.Regular.Square }),
+ new RadioButton("Grid centre",
+ () => rotationInfo.Value = rotationInfo.Value with { Origin = RotationOrigin.GridCentre },
+ () => new SpriteIcon { Icon = FontAwesome.Regular.PlusSquare }),
selectionCentreButton = new RadioButton("Selection centre",
() => rotationInfo.Value = rotationInfo.Value with { Origin = RotationOrigin.SelectionCentre },
() => new SpriteIcon { Icon = FontAwesome.Solid.VectorSquare })
@@ -95,7 +95,7 @@ namespace osu.Game.Rulesets.Osu.Edit
rotationInfo.BindValueChanged(rotation =>
{
- rotationHandler.Update(rotation.NewValue.Degrees, rotation.NewValue.Origin == RotationOrigin.PlayfieldCentre ? gridToolbox.StartPosition.Value : null);
+ rotationHandler.Update(rotation.NewValue.Degrees, rotation.NewValue.Origin == RotationOrigin.GridCentre ? gridToolbox.StartPosition.Value : null);
});
}
@@ -116,7 +116,7 @@ namespace osu.Game.Rulesets.Osu.Edit
public enum RotationOrigin
{
- PlayfieldCentre,
+ GridCentre,
SelectionCentre
}
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
index 0f04efcfa5..15ed4c59c3 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Rulesets.Osu.Edit
private readonly OsuGridToolboxGroup gridToolbox;
- private readonly Bindable scaleInfo = new Bindable(new PreciseScaleInfo(1, ScaleOrigin.PlayfieldCentre, true, true));
+ private readonly Bindable scaleInfo = new Bindable(new PreciseScaleInfo(1, ScaleOrigin.GridCentre, true, true));
private SliderWithTextBoxInput scaleInput = null!;
private BindableNumber scaleInputBindable = null!;
@@ -68,9 +68,9 @@ namespace osu.Game.Rulesets.Osu.Edit
RelativeSizeAxes = Axes.X,
Items = new[]
{
- playfieldCentreButton = new RadioButton("Playfield centre",
- () => setOrigin(ScaleOrigin.PlayfieldCentre),
- () => new SpriteIcon { Icon = FontAwesome.Regular.Square }),
+ playfieldCentreButton = new RadioButton("Grid centre",
+ () => setOrigin(ScaleOrigin.GridCentre),
+ () => new SpriteIcon { Icon = FontAwesome.Regular.PlusSquare }),
selectionCentreButton = new RadioButton("Selection centre",
() => setOrigin(ScaleOrigin.SelectionCentre),
() => new SpriteIcon { Icon = FontAwesome.Solid.VectorSquare })
@@ -137,7 +137,7 @@ namespace osu.Game.Rulesets.Osu.Edit
private void updateAxisCheckBoxesEnabled()
{
- if (scaleInfo.Value.Origin == ScaleOrigin.PlayfieldCentre)
+ if (scaleInfo.Value.Origin == ScaleOrigin.GridCentre)
{
toggleAxisAvailable(xCheckBox.Current, true);
toggleAxisAvailable(yCheckBox.Current, true);
@@ -181,11 +181,11 @@ namespace osu.Game.Rulesets.Osu.Edit
updateAxisCheckBoxesEnabled();
}
- private Vector2? getOriginPosition(PreciseScaleInfo scale) => scale.Origin == ScaleOrigin.PlayfieldCentre ? gridToolbox.StartPosition.Value : null;
+ private Vector2? getOriginPosition(PreciseScaleInfo scale) => scale.Origin == ScaleOrigin.GridCentre ? gridToolbox.StartPosition.Value : null;
private Axes getAdjustAxis(PreciseScaleInfo scale) => scale.XAxis ? scale.YAxis ? Axes.Both : Axes.X : Axes.Y;
- private float getRotation(PreciseScaleInfo scale) => scale.Origin == ScaleOrigin.PlayfieldCentre ? gridToolbox.GridLinesRotation.Value : 0;
+ private float getRotation(PreciseScaleInfo scale) => scale.Origin == ScaleOrigin.GridCentre ? gridToolbox.GridLinesRotation.Value : 0;
private void setAxis(bool x, bool y)
{
@@ -210,7 +210,7 @@ namespace osu.Game.Rulesets.Osu.Edit
public enum ScaleOrigin
{
- PlayfieldCentre,
+ GridCentre,
SelectionCentre
}
From a80e3337860773790c88010a7592219984a31570 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 17:27:04 +0200
Subject: [PATCH 125/924] add playfield origin as third origin option
---
.../Edit/PreciseRotationPopover.cs | 17 ++++++++++++-
.../Edit/PreciseScalePopover.cs | 24 ++++++++++++++++---
2 files changed, 37 insertions(+), 4 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
index 4a1ccc4b61..352debf500 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseRotationPopover.cs
@@ -1,6 +1,7 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
+using System;
using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
@@ -8,6 +9,7 @@ using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites;
using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Rulesets.Osu.UI;
using osu.Game.Screens.Edit.Components.RadioButtons;
using osu.Game.Screens.Edit.Compose.Components;
using osuTK;
@@ -63,6 +65,9 @@ namespace osu.Game.Rulesets.Osu.Edit
new RadioButton("Grid centre",
() => rotationInfo.Value = rotationInfo.Value with { Origin = RotationOrigin.GridCentre },
() => new SpriteIcon { Icon = FontAwesome.Regular.PlusSquare }),
+ new RadioButton("Playfield centre",
+ () => rotationInfo.Value = rotationInfo.Value with { Origin = RotationOrigin.PlayfieldCentre },
+ () => new SpriteIcon { Icon = FontAwesome.Regular.Square }),
selectionCentreButton = new RadioButton("Selection centre",
() => rotationInfo.Value = rotationInfo.Value with { Origin = RotationOrigin.SelectionCentre },
() => new SpriteIcon { Icon = FontAwesome.Solid.VectorSquare })
@@ -95,10 +100,19 @@ namespace osu.Game.Rulesets.Osu.Edit
rotationInfo.BindValueChanged(rotation =>
{
- rotationHandler.Update(rotation.NewValue.Degrees, rotation.NewValue.Origin == RotationOrigin.GridCentre ? gridToolbox.StartPosition.Value : null);
+ rotationHandler.Update(rotation.NewValue.Degrees, getOriginPosition(rotation.NewValue));
});
}
+ private Vector2? getOriginPosition(PreciseRotationInfo rotation) =>
+ rotation.Origin switch
+ {
+ RotationOrigin.GridCentre => gridToolbox.StartPosition.Value,
+ RotationOrigin.PlayfieldCentre => OsuPlayfield.BASE_SIZE / 2,
+ RotationOrigin.SelectionCentre => null,
+ _ => throw new ArgumentOutOfRangeException(nameof(rotation))
+ };
+
protected override void PopIn()
{
base.PopIn();
@@ -117,6 +131,7 @@ namespace osu.Game.Rulesets.Osu.Edit
public enum RotationOrigin
{
GridCentre,
+ PlayfieldCentre,
SelectionCentre
}
diff --git a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
index 15ed4c59c3..dff370d259 100644
--- a/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
+++ b/osu.Game.Rulesets.Osu/Edit/PreciseScalePopover.cs
@@ -10,6 +10,7 @@ using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites;
using osu.Game.Graphics.UserInterface;
using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Rulesets.Osu.UI;
using osu.Game.Screens.Edit.Components.RadioButtons;
using osuTK;
@@ -27,6 +28,7 @@ namespace osu.Game.Rulesets.Osu.Edit
private BindableNumber scaleInputBindable = null!;
private EditorRadioButtonCollection scaleOrigin = null!;
+ private RadioButton gridCentreButton = null!;
private RadioButton playfieldCentreButton = null!;
private RadioButton selectionCentreButton = null!;
@@ -68,9 +70,12 @@ namespace osu.Game.Rulesets.Osu.Edit
RelativeSizeAxes = Axes.X,
Items = new[]
{
- playfieldCentreButton = new RadioButton("Grid centre",
+ gridCentreButton = new RadioButton("Grid centre",
() => setOrigin(ScaleOrigin.GridCentre),
() => new SpriteIcon { Icon = FontAwesome.Regular.PlusSquare }),
+ playfieldCentreButton = new RadioButton("Playfield centre",
+ () => setOrigin(ScaleOrigin.PlayfieldCentre),
+ () => new SpriteIcon { Icon = FontAwesome.Regular.Square }),
selectionCentreButton = new RadioButton("Selection centre",
() => setOrigin(ScaleOrigin.SelectionCentre),
() => new SpriteIcon { Icon = FontAwesome.Solid.VectorSquare })
@@ -99,6 +104,10 @@ namespace osu.Game.Rulesets.Osu.Edit
},
}
};
+ gridCentreButton.Selected.DisabledChanged += isDisabled =>
+ {
+ gridCentreButton.TooltipText = isDisabled ? "The current selection cannot be scaled relative to grid centre." : string.Empty;
+ };
playfieldCentreButton.Selected.DisabledChanged += isDisabled =>
{
playfieldCentreButton.TooltipText = isDisabled ? "The current selection cannot be scaled relative to playfield centre." : string.Empty;
@@ -125,6 +134,7 @@ namespace osu.Game.Rulesets.Osu.Edit
selectionCentreButton.Selected.Disabled = !(scaleHandler.CanScaleX.Value || scaleHandler.CanScaleY.Value);
playfieldCentreButton.Selected.Disabled = scaleHandler.IsScalingSlider.Value && !selectionCentreButton.Selected.Disabled;
+ gridCentreButton.Selected.Disabled = playfieldCentreButton.Selected.Disabled;
scaleOrigin.Items.First(b => !b.Selected.Disabled).Select();
@@ -137,7 +147,7 @@ namespace osu.Game.Rulesets.Osu.Edit
private void updateAxisCheckBoxesEnabled()
{
- if (scaleInfo.Value.Origin == ScaleOrigin.GridCentre)
+ if (scaleInfo.Value.Origin != ScaleOrigin.SelectionCentre)
{
toggleAxisAvailable(xCheckBox.Current, true);
toggleAxisAvailable(yCheckBox.Current, true);
@@ -181,7 +191,14 @@ namespace osu.Game.Rulesets.Osu.Edit
updateAxisCheckBoxesEnabled();
}
- private Vector2? getOriginPosition(PreciseScaleInfo scale) => scale.Origin == ScaleOrigin.GridCentre ? gridToolbox.StartPosition.Value : null;
+ private Vector2? getOriginPosition(PreciseScaleInfo scale) =>
+ scale.Origin switch
+ {
+ ScaleOrigin.GridCentre => gridToolbox.StartPosition.Value,
+ ScaleOrigin.PlayfieldCentre => OsuPlayfield.BASE_SIZE / 2,
+ ScaleOrigin.SelectionCentre => null,
+ _ => throw new ArgumentOutOfRangeException(nameof(scale))
+ };
private Axes getAdjustAxis(PreciseScaleInfo scale) => scale.XAxis ? scale.YAxis ? Axes.Both : Axes.X : Axes.Y;
@@ -211,6 +228,7 @@ namespace osu.Game.Rulesets.Osu.Edit
public enum ScaleOrigin
{
GridCentre,
+ PlayfieldCentre,
SelectionCentre
}
From 2bbaa8e43ccce0a1bf42f2c5790ad469a81a195e Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 18:12:55 +0200
Subject: [PATCH 126/924] make flips grid-type aware
---
.../Edit/OsuSelectionHandler.cs | 26 ++++++++++++++++---
1 file changed, 22 insertions(+), 4 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
index 7d6ef66909..1334dbdbec 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
@@ -107,10 +107,28 @@ namespace osu.Game.Rulesets.Osu.Edit
// If we're flipping over the origin, we take the grid origin position from the grid toolbox.
var flipQuad = flipOverOrigin ? new Quad(gridToolbox.StartPositionX.Value, gridToolbox.StartPositionY.Value, 0, 0) : GeometryUtils.GetSurroundingQuad(hitObjects);
- // If we're flipping over the origin, we take the grid rotation from the grid toolbox.
- // We want to normalize the rotation angle to -45 to 45 degrees, so horizontal vs vertical flip is not mixed up by the rotation and it stays intuitive to use.
- var flipAxis = flipOverOrigin ? GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 405) % 90 - 45)) : Vector2.UnitX;
- flipAxis = direction == Direction.Vertical ? flipAxis.PerpendicularLeft : flipAxis;
+ Vector2 flipAxis = direction == Direction.Vertical ? Vector2.UnitY : Vector2.UnitX;
+
+ if (flipOverOrigin)
+ {
+ // If we're flipping over the origin, we take one of the axes of the grid.
+ // Take the axis closest to the direction we want to flip over.
+ switch (gridToolbox.GridType.Value)
+ {
+ case PositionSnapGridType.Square:
+ flipAxis = GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 405) % 90 - 45));
+ flipAxis = direction == Direction.Vertical ? flipAxis.PerpendicularLeft : flipAxis;
+ break;
+
+ case PositionSnapGridType.Triangle:
+ // Hex grid has 3 axes, so you can not directly flip over one of the axes,
+ // however it's still possible to achieve that flip by combining multiple flips over the other axes.
+ flipAxis = direction == Direction.Vertical
+ ? GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 390) % 60 + 60))
+ : GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 390) % 60 - 60));
+ break;
+ }
+ }
var controlPointFlipQuad = new Quad();
From 952540024eeb41c039d5a1072d7b1d520ff2cab3 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 20:43:16 +0200
Subject: [PATCH 127/924] addition bank toggles in compose
---
osu.Game/Rulesets/Edit/HitObjectComposer.cs | 24 +++-
.../Components/ComposeBlueprintContainer.cs | 9 +-
.../Components/EditorSelectionHandler.cs | 131 +++++++++++++++++-
3 files changed, 149 insertions(+), 15 deletions(-)
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index 3c38a7258e..ac9c830f03 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -85,6 +85,7 @@ namespace osu.Game.Rulesets.Edit
private EditorRadioButtonCollection toolboxCollection;
private FillFlowContainer togglesCollection;
private FillFlowContainer sampleBankTogglesCollection;
+ private FillFlowContainer sampleAdditionBankTogglesCollection;
private IBindable hasTiming;
private Bindable autoSeekOnPlacement;
@@ -184,7 +185,17 @@ namespace osu.Game.Rulesets.Edit
Direction = FillDirection.Vertical,
Spacing = new Vector2(0, 5),
},
- }
+ },
+ new EditorToolboxGroup("additions (Alt-Q~R)")
+ {
+ Child = sampleAdditionBankTogglesCollection = new FillFlowContainer
+ {
+ RelativeSizeAxes = Axes.X,
+ AutoSizeAxes = Axes.Y,
+ Direction = FillDirection.Vertical,
+ Spacing = new Vector2(0, 5),
+ },
+ },
}
},
}
@@ -230,6 +241,7 @@ namespace osu.Game.Rulesets.Edit
togglesCollection.AddRange(TernaryStates.Select(b => new DrawableTernaryButton(b)));
sampleBankTogglesCollection.AddRange(BlueprintContainer.SampleBankTernaryStates.Select(b => new DrawableTernaryButton(b)));
+ sampleAdditionBankTogglesCollection.AddRange(BlueprintContainer.SampleAdditionBankTernaryStates.Select(b => new DrawableTernaryButton(b)));
setSelectTool();
@@ -358,7 +370,7 @@ namespace osu.Game.Rulesets.Edit
protected override bool OnKeyDown(KeyDownEvent e)
{
- if (e.ControlPressed || e.AltPressed || e.SuperPressed)
+ if (e.ControlPressed || e.SuperPressed)
return false;
if (checkLeftToggleFromKey(e.Key, out int leftIndex))
@@ -375,9 +387,11 @@ namespace osu.Game.Rulesets.Edit
if (checkRightToggleFromKey(e.Key, out int rightIndex))
{
- var item = e.ShiftPressed
- ? sampleBankTogglesCollection.ElementAtOrDefault(rightIndex)
- : togglesCollection.ElementAtOrDefault(rightIndex);
+ var item = e.AltPressed
+ ? sampleAdditionBankTogglesCollection.ElementAtOrDefault(rightIndex)
+ : e.ShiftPressed
+ ? sampleBankTogglesCollection.ElementAtOrDefault(rightIndex)
+ : togglesCollection.ElementAtOrDefault(rightIndex);
if (item is DrawableTernaryButton button)
{
diff --git a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
index fc8bce4c96..671180348d 100644
--- a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
@@ -62,7 +62,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
private void load()
{
MainTernaryStates = CreateTernaryButtons().ToArray();
- SampleBankTernaryStates = createSampleBankTernaryButtons().ToArray();
+ SampleBankTernaryStates = createSampleBankTernaryButtons(SelectionHandler.SelectionBankStates).ToArray();
+ SampleAdditionBankTernaryStates = createSampleBankTernaryButtons(SelectionHandler.SelectionAdditionBankStates).ToArray();
AddInternal(new DrawableRulesetDependenciesProvidingContainer(Composer.Ruleset)
{
@@ -219,6 +220,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
public TernaryButton[] SampleBankTernaryStates { get; private set; }
+ public TernaryButton[] SampleAdditionBankTernaryStates { get; private set; }
+
///
/// Create all ternary states required to be displayed to the user.
///
@@ -231,9 +234,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
yield return new TernaryButton(kvp.Value, kvp.Key.Replace("hit", string.Empty).Titleize(), () => GetIconForSample(kvp.Key));
}
- private IEnumerable createSampleBankTernaryButtons()
+ private IEnumerable createSampleBankTernaryButtons(Dictionary> sampleBankStates)
{
- foreach (var kvp in SelectionHandler.SelectionBankStates)
+ foreach (var kvp in sampleBankStates)
yield return new TernaryButton(kvp.Value, kvp.Key.Titleize(), () => getIconForBank(kvp.Key));
}
diff --git a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
index a4efe66bf8..04baaa6134 100644
--- a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
@@ -58,6 +58,11 @@ namespace osu.Game.Screens.Edit.Compose.Components
///
public readonly Dictionary> SelectionBankStates = new Dictionary>();
+ ///
+ /// The state of each sample addition bank type for all selected hitobjects.
+ ///
+ public readonly Dictionary> SelectionAdditionBankStates = new Dictionary>();
+
///
/// Set up ternary state bindables and bind them to selection/hitobject changes (in both directions)
///
@@ -90,7 +95,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
// Never remove a sample bank.
// These are basically radio buttons, not toggles.
- if (SelectedItems.All(h => h.Samples.All(s => s.Bank == bankName)))
+ if (SelectedItems.All(h => h.Samples.Where(o => o.Name == HitSampleInfo.HIT_NORMAL).All(s => s.Bank == bankName)))
bindable.Value = TernaryState.True;
}
@@ -127,8 +132,70 @@ namespace osu.Game.Screens.Edit.Compose.Components
SelectionBankStates[bankName] = bindable;
}
+ foreach (string bankName in HitSampleInfo.AllBanks.Prepend(HIT_BANK_AUTO))
+ {
+ var bindable = new Bindable
+ {
+ Description = bankName.Titleize()
+ };
+
+ bindable.ValueChanged += state =>
+ {
+ switch (state.NewValue)
+ {
+ case TernaryState.False:
+ if (SelectedItems.Count == 0)
+ {
+ // Ensure that if this is the last selected bank, it should remain selected.
+ if (SelectionAdditionBankStates.Values.All(b => b.Value == TernaryState.False))
+ bindable.Value = TernaryState.True;
+ }
+
+ // Auto should never apply when there is a selection made.
+ // Completely empty selections should be allowed in the case that none of the selected objects have any addition samples.
+ break;
+
+ case TernaryState.True:
+ if (SelectedItems.Count == 0)
+ {
+ // Ensure the user can't stack multiple bank selections when there's no hitobject selection.
+ // Note that in normal scenarios this is sorted out by the feedback from applying the bank to the selected objects.
+ foreach (var other in SelectionAdditionBankStates.Values)
+ {
+ if (other != bindable)
+ other.Value = TernaryState.False;
+ }
+ }
+ else
+ {
+ // Auto should just not apply if there's a selection already made.
+ // Maybe we could make it a disabled button in the future, but right now the editor buttons don't support disabled state.
+ if (bankName == HIT_BANK_AUTO)
+ {
+ bindable.Value = TernaryState.False;
+ break;
+ }
+
+ // If none of the selected objects have any addition samples, we should not apply the bank.
+ if (SelectedItems.All(h => h.Samples.All(o => o.Name == HitSampleInfo.HIT_NORMAL)))
+ {
+ bindable.Value = TernaryState.False;
+ break;
+ }
+
+ SetSampleAdditionBank(bankName);
+ }
+
+ break;
+ }
+ };
+
+ SelectionAdditionBankStates[bankName] = bindable;
+ }
+
// start with normal selected.
SelectionBankStates[SampleControlPoint.DEFAULT_BANK].Value = TernaryState.True;
+ SelectionAdditionBankStates[SampleControlPoint.DEFAULT_BANK].Value = TernaryState.True;
foreach (string sampleName in HitSampleInfo.AllAdditions)
{
@@ -186,7 +253,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
foreach ((string bankName, var bindable) in SelectionBankStates)
{
- bindable.Value = GetStateFromSelection(samplesInSelection.SelectMany(s => s), h => h.Bank == bankName);
+ bindable.Value = GetStateFromSelection(samplesInSelection.SelectMany(s => s).Where(o => o.Name == HitSampleInfo.HIT_NORMAL), h => h.Bank == bankName);
+ }
+
+ foreach ((string bankName, var bindable) in SelectionAdditionBankStates)
+ {
+ bindable.Value = GetStateFromSelection(samplesInSelection.SelectMany(s => s).Where(o => o.Name != HitSampleInfo.HIT_NORMAL), h => h.Bank == bankName);
}
IEnumerable> enumerateAllSamples(HitObject hitObject)
@@ -213,12 +285,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
{
bool hasRelevantBank(HitObject hitObject)
{
- bool result = hitObject.Samples.All(s => s.Bank == bankName);
+ bool result = hitObject.Samples.Where(o => o.Name == HitSampleInfo.HIT_NORMAL).All(s => s.Bank == bankName);
if (hitObject is IHasRepeats hasRepeats)
{
foreach (var node in hasRepeats.NodeSamples)
- result &= node.All(s => s.Bank == bankName);
+ result &= node.Where(o => o.Name == HitSampleInfo.HIT_NORMAL).All(s => s.Bank == bankName);
}
return result;
@@ -229,15 +301,54 @@ namespace osu.Game.Screens.Edit.Compose.Components
EditorBeatmap.PerformOnSelection(h =>
{
- if (h.Samples.All(s => s.Bank == bankName))
+ if (h.Samples.Where(o => o.Name == HitSampleInfo.HIT_NORMAL).All(s => s.Bank == bankName))
return;
- h.Samples = h.Samples.Select(s => s.With(newBank: bankName)).ToList();
+ h.Samples = h.Samples.Select(s => s.Name == HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
if (h is IHasRepeats hasRepeats)
{
for (int i = 0; i < hasRepeats.NodeSamples.Count; ++i)
- hasRepeats.NodeSamples[i] = hasRepeats.NodeSamples[i].Select(s => s.With(newBank: bankName)).ToList();
+ hasRepeats.NodeSamples[i] = hasRepeats.NodeSamples[i].Select(s => s.Name == HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
+ }
+
+ EditorBeatmap.Update(h);
+ });
+ }
+
+ ///
+ /// Sets the sample addition bank for all selected s.
+ ///
+ /// The name of the sample bank.
+ public void SetSampleAdditionBank(string bankName)
+ {
+ bool hasRelevantBank(HitObject hitObject)
+ {
+ bool result = hitObject.Samples.Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(s => s.Bank == bankName);
+
+ if (hitObject is IHasRepeats hasRepeats)
+ {
+ foreach (var node in hasRepeats.NodeSamples)
+ result &= node.Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(s => s.Bank == bankName);
+ }
+
+ return result;
+ }
+
+ if (SelectedItems.All(hasRelevantBank))
+ return;
+
+ EditorBeatmap.PerformOnSelection(h =>
+ {
+ if (h.Samples.Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(s => s.Bank == bankName))
+ return;
+
+ h.Samples = h.Samples.Select(s => s.Name != HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
+
+ if (h is IHasRepeats hasRepeats)
+ {
+ for (int i = 0; i < hasRepeats.NodeSamples.Count; ++i)
+ hasRepeats.NodeSamples[i] = hasRepeats.NodeSamples[i].Select(s => s.Name != HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
}
EditorBeatmap.Update(h);
@@ -366,6 +477,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
Items = SelectionBankStates.Select(kvp =>
new TernaryStateToggleMenuItem(kvp.Value.Description) { State = { BindTarget = kvp.Value } }).ToArray()
};
+
+ yield return new OsuMenuItem("Addition bank")
+ {
+ Items = SelectionAdditionBankStates.Select(kvp =>
+ new TernaryStateToggleMenuItem(kvp.Value.Description) { State = { BindTarget = kvp.Value } }).ToArray()
+ };
}
#endregion
From 5e86a01e5e3e91404d5021572cd8170661d59618 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 20:59:46 +0200
Subject: [PATCH 128/924] allow hotkeys in sample point piece
---
osu.Game/Rulesets/Edit/HitObjectComposer.cs | 28 +++++++++++++------
.../Components/Timeline/SamplePointPiece.cs | 19 +++++++++----
2 files changed, 33 insertions(+), 14 deletions(-)
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index ac9c830f03..f2713739b9 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -373,6 +373,8 @@ namespace osu.Game.Rulesets.Edit
if (e.ControlPressed || e.SuperPressed)
return false;
+ bool handled = false;
+
if (checkLeftToggleFromKey(e.Key, out int leftIndex))
{
var item = toolboxCollection.Items.ElementAtOrDefault(leftIndex);
@@ -387,20 +389,30 @@ namespace osu.Game.Rulesets.Edit
if (checkRightToggleFromKey(e.Key, out int rightIndex))
{
- var item = e.AltPressed
- ? sampleAdditionBankTogglesCollection.ElementAtOrDefault(rightIndex)
- : e.ShiftPressed
- ? sampleBankTogglesCollection.ElementAtOrDefault(rightIndex)
- : togglesCollection.ElementAtOrDefault(rightIndex);
+ if (e.ShiftPressed || e.AltPressed)
+ {
+ if (e.ShiftPressed)
+ attemptToggle(rightIndex, sampleBankTogglesCollection);
+
+ if (e.AltPressed)
+ attemptToggle(rightIndex, sampleAdditionBankTogglesCollection);
+ }
+ else
+ attemptToggle(rightIndex, togglesCollection);
+ }
+
+ return handled || base.OnKeyDown(e);
+
+ void attemptToggle(int index, FillFlowContainer collection)
+ {
+ var item = collection.ElementAtOrDefault(index);
if (item is DrawableTernaryButton button)
{
button.Button.Toggle();
- return true;
+ handled = true;
}
}
-
- return base.OnKeyDown(e);
}
private bool checkLeftToggleFromKey(Key key, out int index)
diff --git a/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs b/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
index 8c7603021a..07c6cab7a1 100644
--- a/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/Timeline/SamplePointPiece.cs
@@ -381,20 +381,27 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
protected override bool OnKeyDown(KeyDownEvent e)
{
- if (e.ControlPressed || e.AltPressed || e.SuperPressed || !checkRightToggleFromKey(e.Key, out int rightIndex))
+ if (e.ControlPressed || e.SuperPressed || !checkRightToggleFromKey(e.Key, out int rightIndex))
return base.OnKeyDown(e);
- if (e.ShiftPressed)
+ if (e.ShiftPressed || e.AltPressed)
{
string? newBank = banks.ElementAtOrDefault(rightIndex);
if (string.IsNullOrEmpty(newBank))
return true;
- setBank(newBank);
- updatePrimaryBankState();
- setAdditionBank(newBank);
- updateAdditionBankState();
+ if (e.ShiftPressed)
+ {
+ setBank(newBank);
+ updatePrimaryBankState();
+ }
+
+ if (e.AltPressed)
+ {
+ setAdditionBank(newBank);
+ updateAdditionBankState();
+ }
}
else
{
From df7a42a00e95ceae944114fe162f266a5fc7708d Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 22:33:23 +0200
Subject: [PATCH 129/924] fix placement samples
---
osu.Game/Rulesets/Edit/PlacementBlueprint.cs | 37 +++++++++++--------
.../Components/ComposeBlueprintContainer.cs | 18 ++++++++-
2 files changed, 38 insertions(+), 17 deletions(-)
diff --git a/osu.Game/Rulesets/Edit/PlacementBlueprint.cs b/osu.Game/Rulesets/Edit/PlacementBlueprint.cs
index 2817e26abd..26b18828d3 100644
--- a/osu.Game/Rulesets/Edit/PlacementBlueprint.cs
+++ b/osu.Game/Rulesets/Edit/PlacementBlueprint.cs
@@ -37,6 +37,11 @@ namespace osu.Game.Rulesets.Edit
///
public bool AutomaticBankAssignment { get; set; }
+ ///
+ /// Whether the sample addition bank should be taken from the previous hit objects.
+ ///
+ public bool AutomaticAdditionBankAssignment { get; set; }
+
///
/// The that is being placed.
///
@@ -157,26 +162,26 @@ namespace osu.Game.Rulesets.Edit
}
var lastHitObject = getPreviousHitObject();
+ var lastHitNormal = lastHitObject?.Samples?.FirstOrDefault(o => o.Name == HitSampleInfo.HIT_NORMAL);
- if (AutomaticBankAssignment)
+ if (AutomaticAdditionBankAssignment)
{
- // Create samples based on the sample settings of the previous hit object
- if (lastHitObject != null)
- {
- for (int i = 0; i < HitObject.Samples.Count; i++)
- HitObject.Samples[i] = lastHitObject.CreateHitSampleInfo(HitObject.Samples[i].Name);
- }
+ // Inherit the addition bank from the previous hit object
+ // If there is no previous addition, inherit from the normal sample
+ var lastAddition = lastHitObject?.Samples?.FirstOrDefault(o => o.Name != HitSampleInfo.HIT_NORMAL) ?? lastHitNormal;
+
+ if (lastAddition != null)
+ HitObject.Samples = HitObject.Samples.Select(s => s.Name != HitSampleInfo.HIT_NORMAL ? s.With(newBank: lastAddition.Bank) : s).ToList();
}
- else
- {
- var lastHitNormal = lastHitObject?.Samples?.FirstOrDefault(o => o.Name == HitSampleInfo.HIT_NORMAL);
- if (lastHitNormal != null)
- {
- // Only inherit the volume from the previous hit object
- for (int i = 0; i < HitObject.Samples.Count; i++)
- HitObject.Samples[i] = HitObject.Samples[i].With(newVolume: lastHitNormal.Volume);
- }
+ if (lastHitNormal != null)
+ {
+ if (AutomaticBankAssignment)
+ // Inherit the bank from the previous hit object
+ HitObject.Samples = HitObject.Samples.Select(s => s.Name == HitSampleInfo.HIT_NORMAL ? s.With(newBank: lastHitNormal.Bank) : s).ToList();
+
+ // Inherit the volume from the previous hit object
+ HitObject.Samples = HitObject.Samples.Select(s => s.With(newVolume: lastHitNormal.Volume)).ToList();
}
if (HitObject is IHasRepeats hasRepeats)
diff --git a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
index 671180348d..fc81bc5706 100644
--- a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
@@ -89,6 +89,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
foreach (var kvp in SelectionHandler.SelectionBankStates)
kvp.Value.BindValueChanged(_ => updatePlacementSamples());
+
+ foreach (var kvp in SelectionHandler.SelectionAdditionBankStates)
+ kvp.Value.BindValueChanged(_ => updatePlacementSamples());
}
protected override void TransferBlueprintFor(HitObject hitObject, DrawableHitObject drawableObject)
@@ -177,6 +180,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
foreach (var kvp in SelectionHandler.SelectionBankStates)
bankChanged(kvp.Key, kvp.Value.Value);
+
+ foreach (var kvp in SelectionHandler.SelectionAdditionBankStates)
+ additionBankChanged(kvp.Key, kvp.Value.Value);
}
private void sampleChanged(string sampleName, TernaryState state)
@@ -208,7 +214,17 @@ namespace osu.Game.Screens.Edit.Compose.Components
if (bankName == EditorSelectionHandler.HIT_BANK_AUTO)
CurrentPlacement.AutomaticBankAssignment = state == TernaryState.True;
else if (state == TernaryState.True)
- CurrentPlacement.HitObject.Samples = CurrentPlacement.HitObject.Samples.Select(s => s.With(newBank: bankName)).ToList();
+ CurrentPlacement.HitObject.Samples = CurrentPlacement.HitObject.Samples.Select(s => s.Name == HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
+ }
+
+ private void additionBankChanged(string bankName, TernaryState state)
+ {
+ if (CurrentPlacement == null) return;
+
+ if (bankName == EditorSelectionHandler.HIT_BANK_AUTO)
+ CurrentPlacement.AutomaticAdditionBankAssignment = state == TernaryState.True;
+ else if (state == TernaryState.True)
+ CurrentPlacement.HitObject.Samples = CurrentPlacement.HitObject.Samples.Select(s => s.Name != HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
}
public readonly Bindable NewCombo = new Bindable { Description = "New Combo" };
From 9f02a1f1bf248a3ea395f63e6da6eb4ce19ef639 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 22:50:15 +0200
Subject: [PATCH 130/924] fix addition on node sample not working
---
.../Components/EditorSelectionHandler.cs | 22 +++++++++----------
1 file changed, 11 insertions(+), 11 deletions(-)
diff --git a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
index 04baaa6134..3a0428e7fc 100644
--- a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
@@ -176,8 +176,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
break;
}
- // If none of the selected objects have any addition samples, we should not apply the bank.
- if (SelectedItems.All(h => h.Samples.All(o => o.Name == HitSampleInfo.HIT_NORMAL)))
+ // If none of the selected objects have any addition samples, we should not apply the addition bank.
+ if (SelectedItems.SelectMany(enumerateAllSamples).All(h => h.All(o => o.Name == HitSampleInfo.HIT_NORMAL)))
{
bindable.Value = TernaryState.False;
break;
@@ -260,16 +260,16 @@ namespace osu.Game.Screens.Edit.Compose.Components
{
bindable.Value = GetStateFromSelection(samplesInSelection.SelectMany(s => s).Where(o => o.Name != HitSampleInfo.HIT_NORMAL), h => h.Bank == bankName);
}
+ }
- IEnumerable> enumerateAllSamples(HitObject hitObject)
+ private IEnumerable> enumerateAllSamples(HitObject hitObject)
+ {
+ yield return hitObject.Samples;
+
+ if (hitObject is IHasRepeats withRepeats)
{
- yield return hitObject.Samples;
-
- if (hitObject is IHasRepeats withRepeats)
- {
- foreach (var node in withRepeats.NodeSamples)
- yield return node;
- }
+ foreach (var node in withRepeats.NodeSamples)
+ yield return node;
}
}
@@ -340,7 +340,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
EditorBeatmap.PerformOnSelection(h =>
{
- if (h.Samples.Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(s => s.Bank == bankName))
+ if (enumerateAllSamples(h).SelectMany(o => o).Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(s => s.Bank == bankName))
return;
h.Samples = h.Samples.Select(s => s.Name != HitSampleInfo.HIT_NORMAL ? s.With(newBank: bankName) : s).ToList();
From 29c2e821ea3e66f9b7846bae4a19a419cdf38d95 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 22:50:25 +0200
Subject: [PATCH 131/924] extend tests
---
.../TestSceneHitObjectSampleAdjustments.cs | 136 ++++++++++++++++--
1 file changed, 123 insertions(+), 13 deletions(-)
diff --git a/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs b/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
index 558d8dce94..e962d3975c 100644
--- a/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
+++ b/osu.Game.Tests/Visual/Editing/TestSceneHitObjectSampleAdjustments.cs
@@ -321,6 +321,12 @@ namespace osu.Game.Tests.Visual.Editing
}
});
+ AddStep("add whistle addition", () =>
+ {
+ foreach (var h in EditorBeatmap.HitObjects)
+ h.Samples.Add(new HitSampleInfo(HitSampleInfo.HIT_WHISTLE, HitSampleInfo.BANK_SOFT));
+ });
+
AddStep("select both objects", () => EditorBeatmap.SelectedHitObjects.AddRange(EditorBeatmap.HitObjects));
hitObjectHasSampleBank(0, HitSampleInfo.BANK_SOFT);
@@ -333,8 +339,10 @@ namespace osu.Game.Tests.Visual.Editing
InputManager.ReleaseKey(Key.ShiftLeft);
});
- hitObjectHasSampleBank(0, HitSampleInfo.BANK_NORMAL);
- hitObjectHasSampleBank(1, HitSampleInfo.BANK_NORMAL);
+ hitObjectHasSampleNormalBank(0, HitSampleInfo.BANK_NORMAL);
+ hitObjectHasSampleNormalBank(1, HitSampleInfo.BANK_NORMAL);
+ hitObjectHasSampleAdditionBank(0, HitSampleInfo.BANK_SOFT);
+ hitObjectHasSampleAdditionBank(1, HitSampleInfo.BANK_SOFT);
AddStep("Press drum bank shortcut", () =>
{
@@ -343,8 +351,10 @@ namespace osu.Game.Tests.Visual.Editing
InputManager.ReleaseKey(Key.ShiftLeft);
});
- hitObjectHasSampleBank(0, HitSampleInfo.BANK_DRUM);
- hitObjectHasSampleBank(1, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleNormalBank(0, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleNormalBank(1, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleAdditionBank(0, HitSampleInfo.BANK_SOFT);
+ hitObjectHasSampleAdditionBank(1, HitSampleInfo.BANK_SOFT);
AddStep("Press auto bank shortcut", () =>
{
@@ -354,8 +364,47 @@ namespace osu.Game.Tests.Visual.Editing
});
// Should be a noop.
- hitObjectHasSampleBank(0, HitSampleInfo.BANK_DRUM);
- hitObjectHasSampleBank(1, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleNormalBank(0, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleNormalBank(1, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleAdditionBank(0, HitSampleInfo.BANK_SOFT);
+ hitObjectHasSampleAdditionBank(1, HitSampleInfo.BANK_SOFT);
+
+ AddStep("Press addition normal bank shortcut", () =>
+ {
+ InputManager.PressKey(Key.AltLeft);
+ InputManager.Key(Key.W);
+ InputManager.ReleaseKey(Key.AltLeft);
+ });
+
+ hitObjectHasSampleNormalBank(0, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleNormalBank(1, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleAdditionBank(0, HitSampleInfo.BANK_NORMAL);
+ hitObjectHasSampleAdditionBank(1, HitSampleInfo.BANK_NORMAL);
+
+ AddStep("Press addition drum bank shortcut", () =>
+ {
+ InputManager.PressKey(Key.AltLeft);
+ InputManager.Key(Key.R);
+ InputManager.ReleaseKey(Key.AltLeft);
+ });
+
+ hitObjectHasSampleNormalBank(0, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleNormalBank(1, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleAdditionBank(0, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleAdditionBank(1, HitSampleInfo.BANK_DRUM);
+
+ AddStep("Press auto bank shortcut", () =>
+ {
+ InputManager.PressKey(Key.AltLeft);
+ InputManager.Key(Key.Q);
+ InputManager.ReleaseKey(Key.AltLeft);
+ });
+
+ // Should be a noop.
+ hitObjectHasSampleNormalBank(0, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleNormalBank(1, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleAdditionBank(0, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSampleAdditionBank(1, HitSampleInfo.BANK_DRUM);
}
[Test]
@@ -373,7 +422,21 @@ namespace osu.Game.Tests.Visual.Editing
InputManager.ReleaseKey(Key.ShiftLeft);
});
- checkPlacementSample(HitSampleInfo.BANK_NORMAL);
+ AddStep("Press soft addition bank shortcut", () =>
+ {
+ InputManager.PressKey(Key.AltLeft);
+ InputManager.Key(Key.E);
+ InputManager.ReleaseKey(Key.AltLeft);
+ });
+
+ checkPlacementSampleBank(HitSampleInfo.BANK_NORMAL);
+
+ AddStep("Press finish sample shortcut", () =>
+ {
+ InputManager.Key(Key.E);
+ });
+
+ checkPlacementSampleAdditionBank(HitSampleInfo.BANK_SOFT);
AddStep("Press drum bank shortcut", () =>
{
@@ -382,7 +445,18 @@ namespace osu.Game.Tests.Visual.Editing
InputManager.ReleaseKey(Key.ShiftLeft);
});
- checkPlacementSample(HitSampleInfo.BANK_DRUM);
+ checkPlacementSampleBank(HitSampleInfo.BANK_DRUM);
+ checkPlacementSampleAdditionBank(HitSampleInfo.BANK_SOFT);
+
+ AddStep("Press drum addition bank shortcut", () =>
+ {
+ InputManager.PressKey(Key.AltLeft);
+ InputManager.Key(Key.R);
+ InputManager.ReleaseKey(Key.AltLeft);
+ });
+
+ checkPlacementSampleBank(HitSampleInfo.BANK_DRUM);
+ checkPlacementSampleAdditionBank(HitSampleInfo.BANK_DRUM);
AddStep("Press auto bank shortcut", () =>
{
@@ -391,15 +465,29 @@ namespace osu.Game.Tests.Visual.Editing
InputManager.ReleaseKey(Key.ShiftLeft);
});
- checkPlacementSample(HitSampleInfo.BANK_NORMAL);
+ checkPlacementSampleBank(HitSampleInfo.BANK_NORMAL);
+ checkPlacementSampleAdditionBank(HitSampleInfo.BANK_DRUM);
+
+ AddStep("Press auto addition bank shortcut", () =>
+ {
+ InputManager.PressKey(Key.AltLeft);
+ InputManager.Key(Key.Q);
+ InputManager.ReleaseKey(Key.AltLeft);
+ });
+
+ checkPlacementSampleBank(HitSampleInfo.BANK_NORMAL);
+ checkPlacementSampleAdditionBank(HitSampleInfo.BANK_NORMAL);
AddStep("Move after second object", () => EditorClock.Seek(750));
- checkPlacementSample(HitSampleInfo.BANK_SOFT);
+ checkPlacementSampleBank(HitSampleInfo.BANK_SOFT);
+ checkPlacementSampleAdditionBank(HitSampleInfo.BANK_SOFT);
AddStep("Move to first object", () => EditorClock.Seek(0));
- checkPlacementSample(HitSampleInfo.BANK_NORMAL);
+ checkPlacementSampleBank(HitSampleInfo.BANK_NORMAL);
+ checkPlacementSampleAdditionBank(HitSampleInfo.BANK_NORMAL);
- void checkPlacementSample(string expected) => AddAssert($"Placement sample is {expected}", () => EditorBeatmap.PlacementObject.Value.Samples.First().Bank, () => Is.EqualTo(expected));
+ void checkPlacementSampleBank(string expected) => AddAssert($"Placement sample is {expected}", () => EditorBeatmap.PlacementObject.Value.Samples.First(s => s.Name == HitSampleInfo.HIT_NORMAL).Bank, () => Is.EqualTo(expected));
+ void checkPlacementSampleAdditionBank(string expected) => AddAssert($"Placement sample addition is {expected}", () => EditorBeatmap.PlacementObject.Value.Samples.First(s => s.Name != HitSampleInfo.HIT_NORMAL).Bank, () => Is.EqualTo(expected));
}
[Test]
@@ -480,7 +568,29 @@ namespace osu.Game.Tests.Visual.Editing
hitObjectHasSamples(2, HitSampleInfo.HIT_NORMAL);
hitObjectNodeHasSampleBank(2, 0, HitSampleInfo.BANK_DRUM);
hitObjectNodeHasSamples(2, 0, HitSampleInfo.HIT_NORMAL);
- hitObjectNodeHasSampleBank(2, 1, HitSampleInfo.BANK_DRUM);
+ hitObjectNodeHasSampleNormalBank(2, 1, HitSampleInfo.BANK_DRUM);
+ hitObjectNodeHasSampleAdditionBank(2, 1, HitSampleInfo.BANK_SOFT);
+ hitObjectNodeHasSamples(2, 1, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_WHISTLE);
+
+ AddStep("set normal addition bank", () =>
+ {
+ InputManager.PressKey(Key.LAlt);
+ InputManager.Key(Key.W);
+ InputManager.ReleaseKey(Key.LAlt);
+ });
+
+ hitObjectHasSampleBank(0, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSamples(0, HitSampleInfo.HIT_NORMAL);
+
+ hitObjectHasSampleBank(1, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSamples(1, HitSampleInfo.HIT_NORMAL);
+
+ hitObjectHasSampleBank(2, HitSampleInfo.BANK_DRUM);
+ hitObjectHasSamples(2, HitSampleInfo.HIT_NORMAL);
+ hitObjectNodeHasSampleBank(2, 0, HitSampleInfo.BANK_DRUM);
+ hitObjectNodeHasSamples(2, 0, HitSampleInfo.HIT_NORMAL);
+ hitObjectNodeHasSampleNormalBank(2, 1, HitSampleInfo.BANK_DRUM);
+ hitObjectNodeHasSampleAdditionBank(2, 1, HitSampleInfo.BANK_NORMAL);
hitObjectNodeHasSamples(2, 1, HitSampleInfo.HIT_NORMAL, HitSampleInfo.HIT_WHISTLE);
}
From e5bc359b8811fcd0281dd6052031e05a950644b5 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Sun, 14 Jul 2024 23:39:19 +0200
Subject: [PATCH 132/924] fix test
---
osu.Game.Tests/Visual/Editing/TestScenePlacementBlueprint.cs | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/osu.Game.Tests/Visual/Editing/TestScenePlacementBlueprint.cs b/osu.Game.Tests/Visual/Editing/TestScenePlacementBlueprint.cs
index e9b442f8dd..fba84108d0 100644
--- a/osu.Game.Tests/Visual/Editing/TestScenePlacementBlueprint.cs
+++ b/osu.Game.Tests/Visual/Editing/TestScenePlacementBlueprint.cs
@@ -123,7 +123,9 @@ namespace osu.Game.Tests.Visual.Editing
AddStep("enable automatic bank assignment", () =>
{
InputManager.PressKey(Key.LShift);
+ InputManager.PressKey(Key.LAlt);
InputManager.Key(Key.Q);
+ InputManager.ReleaseKey(Key.LAlt);
InputManager.ReleaseKey(Key.LShift);
});
AddStep("select circle placement tool", () => InputManager.Key(Key.Number2));
@@ -186,7 +188,9 @@ namespace osu.Game.Tests.Visual.Editing
AddStep("select drum bank", () =>
{
InputManager.PressKey(Key.LShift);
+ InputManager.PressKey(Key.LAlt);
InputManager.Key(Key.R);
+ InputManager.ReleaseKey(Key.LAlt);
InputManager.ReleaseKey(Key.LShift);
});
AddStep("enable clap addition", () => InputManager.Key(Key.R));
From e25642b48472789aaffa5254106d763a4cee9cad Mon Sep 17 00:00:00 2001
From: StanR
Date: Mon, 15 Jul 2024 14:45:31 +0500
Subject: [PATCH 133/924] Implement a bunch of rhythm difficulty calculation
fixes
---
.../Difficulty/Evaluators/RhythmEvaluator.cs | 103 ++++++++++++++----
.../Preprocessing/OsuDifficultyHitObject.cs | 11 +-
2 files changed, 90 insertions(+), 24 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
index f2218a89a7..39c7572c85 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
@@ -2,6 +2,8 @@
// See the LICENCE file in the repository root for full licence text.
using System;
+using System.Collections.Generic;
+using System.Linq;
using osu.Game.Rulesets.Difficulty.Preprocessing;
using osu.Game.Rulesets.Osu.Difficulty.Preprocessing;
using osu.Game.Rulesets.Osu.Objects;
@@ -10,21 +12,65 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
{
public static class RhythmEvaluator
{
- private const int history_time_max = 5000; // 5 seconds of calculatingRhythmBonus max.
- private const double rhythm_multiplier = 0.75;
+ private readonly struct Island : IEquatable
+ {
+ public Island()
+ {
+ }
+
+ public Island(int firstDelta, double epsilon)
+ {
+ AddDelta(firstDelta, epsilon);
+ }
+
+ public List Deltas { get; } = new List();
+
+ public void AddDelta(int delta, double epsilon)
+ {
+ int existingDelta = Deltas.FirstOrDefault(x => Math.Abs(x - delta) >= epsilon);
+
+ Deltas.Add(existingDelta == default ? delta : existingDelta);
+ }
+
+ public double AverageDelta() => Math.Max(Deltas.Average(), OsuDifficultyHitObject.MIN_DELTA_TIME);
+
+ public override int GetHashCode()
+ {
+ // we need to compare all deltas and they must be in the exact same order we added them
+ string joinedDeltas = string.Join(string.Empty, Deltas);
+ return joinedDeltas.GetHashCode();
+ }
+
+ public bool Equals(Island other)
+ {
+ return other.GetHashCode() == GetHashCode();
+ }
+
+ public override bool Equals(object? obj)
+ {
+ return obj?.GetHashCode() == GetHashCode();
+ }
+ }
+
+ private const int history_time_max = 5 * 1000; // 5 seconds of calculatingRhythmBonus max.
+ private const double rhythm_multiplier = 1.14;
+ private const int max_island_size = 7;
///
/// Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current .
///
public static double EvaluateDifficultyOf(DifficultyHitObject current)
{
+ Dictionary islandCounts = new Dictionary();
+
if (current.BaseObject is Spinner)
return 0;
- int previousIslandSize = 0;
-
double rhythmComplexitySum = 0;
- int islandSize = 1;
+
+ var island = new Island();
+ var previousIsland = new Island();
+
double startRatio = 0; // store the ratio of the current start of an island to buff for tighter rhythms
bool firstDeltaSwitch = false;
@@ -50,6 +96,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
double currDelta = currObj.StrainTime;
double prevDelta = prevObj.StrainTime;
double lastDelta = lastObj.StrainTime;
+
double currRatio = 1.0 + 6.0 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - currObj.HitWindowGreat * 0.3) / (currObj.HitWindowGreat * 0.3));
@@ -58,12 +105,17 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
double effectiveRatio = windowPenalty * currRatio;
+ double deltaDifferenceEpsilon = currObj.HitWindowGreat * 0.3;
+
if (firstDeltaSwitch)
{
- if (!(prevDelta > 1.25 * currDelta || prevDelta * 1.25 < currDelta))
+ if (!(Math.Abs(prevDelta - currDelta) > deltaDifferenceEpsilon))
{
- if (islandSize < 7)
- islandSize++; // island is still progressing, count size.
+ if (island.Deltas.Count < max_island_size)
+ {
+ // island is still progressing
+ island.AddDelta((int)currDelta, deltaDifferenceEpsilon);
+ }
}
else
{
@@ -73,33 +125,44 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
if (prevObj.BaseObject is Slider) // bpm change was from a slider, this is easier typically than circle -> circle
effectiveRatio *= 0.25;
- if (previousIslandSize == islandSize) // repeated island size (ex: triplet -> triplet)
- effectiveRatio *= 0.25;
-
- if (previousIslandSize % 2 == islandSize % 2) // repeated island polartiy (2 -> 4, 3 -> 5)
+ if (previousIsland.Deltas.Count % 2 == island.Deltas.Count % 2) // repeated island polartiy (2 -> 4, 3 -> 5)
effectiveRatio *= 0.50;
- if (lastDelta > prevDelta + 10 && prevDelta > currDelta + 10) // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
+ if (lastDelta > prevDelta + deltaDifferenceEpsilon && prevDelta > currDelta + deltaDifferenceEpsilon) // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
effectiveRatio *= 0.125;
- rhythmComplexitySum += Math.Sqrt(effectiveRatio * startRatio) * currHistoricalDecay * Math.Sqrt(4 + islandSize) / 2 * Math.Sqrt(4 + previousIslandSize) / 2;
+ if (islandCounts.ContainsKey(island))
+ {
+ islandCounts[island]++;
+
+ // repeated island (ex: triplet -> triplet)
+ double power = Math.Max(0.75, logistic(island.AverageDelta(), 3, 0.15, 9));
+ effectiveRatio *= Math.Pow(1.0 / islandCounts[island], power);
+ }
+ else
+ {
+ islandCounts.Add(island, 1);
+ }
+
+ rhythmComplexitySum += Math.Sqrt(effectiveRatio * startRatio) * currHistoricalDecay;
startRatio = effectiveRatio;
- previousIslandSize = islandSize; // log the last island size.
+ previousIsland = island;
- if (prevDelta * 1.25 < currDelta) // we're slowing down, stop counting
+ if (prevDelta + deltaDifferenceEpsilon < currDelta) // we're slowing down, stop counting
firstDeltaSwitch = false; // if we're speeding up, this stays true and we keep counting island size.
- islandSize = 1;
+ island = new Island((int)currDelta, deltaDifferenceEpsilon);
}
}
- else if (prevDelta > 1.25 * currDelta) // we want to be speeding up.
+ else if (prevDelta > currDelta + deltaDifferenceEpsilon) // we want to be speeding up.
{
// Begin counting island until we change speed again.
firstDeltaSwitch = true;
startRatio = effectiveRatio;
- islandSize = 1;
+
+ island = new Island((int)currDelta, deltaDifferenceEpsilon);
}
lastObj = prevObj;
@@ -108,5 +171,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
return Math.Sqrt(4 + rhythmComplexitySum * rhythm_multiplier) / 2; //produces multiplier that can be applied to strain. range [1, infinity) (not really though)
}
+
+ private static double logistic(double x, double maxValue, double multiplier, double offset) => (maxValue / (1 + Math.Pow(Math.E, offset - multiplier * x)));
}
}
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs b/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs
index 0e537632b1..95535274c1 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs
@@ -20,7 +20,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
///
public const int NORMALISED_RADIUS = 50; // Change radius to 50 to make 100 the diameter. Easier for mental maths.
- private const int min_delta_time = 25;
+ public const int MIN_DELTA_TIME = 25;
+
private const float maximum_slider_radius = NORMALISED_RADIUS * 2.4f;
private const float assumed_slider_radius = NORMALISED_RADIUS * 1.8f;
@@ -93,7 +94,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
this.lastObject = (OsuHitObject)lastObject;
// Capped to 25ms to prevent difficulty calculation breaking from simultaneous objects.
- StrainTime = Math.Max(DeltaTime, min_delta_time);
+ StrainTime = Math.Max(DeltaTime, MIN_DELTA_TIME);
if (BaseObject is Slider sliderObject)
{
@@ -143,7 +144,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
computeSliderCursorPosition(currentSlider);
// Bonus for repeat sliders until a better per nested object strain system can be achieved.
TravelDistance = currentSlider.LazyTravelDistance * (float)Math.Pow(1 + currentSlider.RepeatCount / 2.5, 1.0 / 2.5);
- TravelTime = Math.Max(currentSlider.LazyTravelTime / clockRate, min_delta_time);
+ TravelTime = Math.Max(currentSlider.LazyTravelTime / clockRate, MIN_DELTA_TIME);
}
// We don't need to calculate either angle or distance when one of the last->curr objects is a spinner
@@ -167,8 +168,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
if (lastObject is Slider lastSlider)
{
- double lastTravelTime = Math.Max(lastSlider.LazyTravelTime / clockRate, min_delta_time);
- MinimumJumpTime = Math.Max(StrainTime - lastTravelTime, min_delta_time);
+ double lastTravelTime = Math.Max(lastSlider.LazyTravelTime / clockRate, MIN_DELTA_TIME);
+ MinimumJumpTime = Math.Max(StrainTime - lastTravelTime, MIN_DELTA_TIME);
//
// There are two types of slider-to-object patterns to consider in order to better approximate the real movement a player will take to jump between the hitobjects.
From 67cb4a2d02e47a2c8bfd493c4def3c19538057e8 Mon Sep 17 00:00:00 2001
From: StanR
Date: Mon, 15 Jul 2024 22:54:25 +0500
Subject: [PATCH 134/924] InspectCode
---
osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
index 39c7572c85..60bc53e7a1 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
@@ -172,6 +172,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
return Math.Sqrt(4 + rhythmComplexitySum * rhythm_multiplier) / 2; //produces multiplier that can be applied to strain. range [1, infinity) (not really though)
}
- private static double logistic(double x, double maxValue, double multiplier, double offset) => (maxValue / (1 + Math.Pow(Math.E, offset - multiplier * x)));
+ private static double logistic(double x, double maxValue, double multiplier, double offset) => (maxValue / (1 + Math.Pow(Math.E, offset - (multiplier * x))));
}
}
From fcc8e7be8a711c9356f0f6df725a1aad6aa86162 Mon Sep 17 00:00:00 2001
From: Dan Balasescu
Date: Tue, 16 Jul 2024 12:09:09 +0900
Subject: [PATCH 135/924] Invert condition to reduce number of brain flips
required
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 7b54d0ae54..0aec0a9d4f 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -192,7 +192,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
// This percentage only considers HitCircles of any value - in this part of the calculation we focus on hitting the timing hit window.
double betterAccuracyPercentage;
int amountHitObjectsWithAccuracy = attributes.HitCircleCount;
- if (!score.Mods.Any(h => h is OsuModClassic cl && cl.NoSliderHeadAccuracy.Value))
+ if (score.Mods.All(h => h is not OsuModClassic cl || !cl.NoSliderHeadAccuracy.Value))
amountHitObjectsWithAccuracy += attributes.SliderCount;
if (amountHitObjectsWithAccuracy > 0)
From ced11e69496eb4cdd6790d8bcf4689420a24c7e1 Mon Sep 17 00:00:00 2001
From: Dan Balasescu
Date: Tue, 16 Jul 2024 12:23:46 +0900
Subject: [PATCH 136/924] Even better readability
---
osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
index 0aec0a9d4f..a4ebcd15a4 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuPerformanceCalculator.cs
@@ -192,7 +192,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
// This percentage only considers HitCircles of any value - in this part of the calculation we focus on hitting the timing hit window.
double betterAccuracyPercentage;
int amountHitObjectsWithAccuracy = attributes.HitCircleCount;
- if (score.Mods.All(h => h is not OsuModClassic cl || !cl.NoSliderHeadAccuracy.Value))
+ if (score.Mods.OfType().All(m => !m.NoSliderHeadAccuracy.Value))
amountHitObjectsWithAccuracy += attributes.SliderCount;
if (amountHitObjectsWithAccuracy > 0)
From c18814817b7d5b1f907574b6cca89f4fdc0efa53 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Tue, 16 Jul 2024 11:17:54 +0200
Subject: [PATCH 137/924] fix test
---
osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs b/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs
index 30e0dbbf2e..d14bd1fc87 100644
--- a/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs
+++ b/osu.Game.Rulesets.Osu.Tests/Editor/TestScenePreciseRotation.cs
@@ -116,7 +116,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
() => EditorBeatmap.HitObjects.OfType().ElementAt(1).Position,
() => Is.EqualTo(OsuPlayfield.BASE_SIZE - new Vector2(200)));
- AddStep("change rotation origin", () => getPopover().ChildrenOfType().ElementAt(1).TriggerClick());
+ AddStep("change rotation origin", () => getPopover().ChildrenOfType().ElementAt(2).TriggerClick());
AddAssert("first object rotated 90deg around selection centre",
() => EditorBeatmap.HitObjects.OfType().ElementAt(0).Position, () => Is.EqualTo(new Vector2(200, 200)));
AddAssert("second object rotated 90deg around selection centre",
From ba501a8eb80cddea92a77cbedea8cfc4c8a540e0 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Tue, 16 Jul 2024 11:30:52 +0200
Subject: [PATCH 138/924] fix addition bank toggle can be switched off with
selection
---
.../Components/EditorSelectionHandler.cs | 18 ++++++++++++++++--
1 file changed, 16 insertions(+), 2 deletions(-)
diff --git a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
index 3a0428e7fc..df8c0176e1 100644
--- a/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/EditorSelectionHandler.cs
@@ -150,9 +150,23 @@ namespace osu.Game.Screens.Edit.Compose.Components
if (SelectionAdditionBankStates.Values.All(b => b.Value == TernaryState.False))
bindable.Value = TernaryState.True;
}
+ else
+ {
+ // Auto should never apply when there is a selection made.
+ if (bankName == HIT_BANK_AUTO)
+ break;
+
+ // Completely empty selections should be allowed in the case that none of the selected objects have any addition samples.
+ // This is also required to stop a bindable feedback loop when a HitObject has zero addition samples (and LINQ `All` below becomes true).
+ if (SelectedItems.SelectMany(enumerateAllSamples).All(h => h.All(o => o.Name == HitSampleInfo.HIT_NORMAL)))
+ break;
+
+ // Never remove a sample bank.
+ // These are basically radio buttons, not toggles.
+ if (SelectedItems.SelectMany(enumerateAllSamples).All(h => h.Where(o => o.Name != HitSampleInfo.HIT_NORMAL).All(s => s.Bank == bankName)))
+ bindable.Value = TernaryState.True;
+ }
- // Auto should never apply when there is a selection made.
- // Completely empty selections should be allowed in the case that none of the selected objects have any addition samples.
break;
case TernaryState.True:
From 7dc006f9bab4f22e326c5692a40a2afc5bfdc566 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Tue, 16 Jul 2024 13:19:01 +0200
Subject: [PATCH 139/924] fix horizontal flip rotation
---
osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
index 1334dbdbec..2dc43deee1 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
@@ -125,7 +125,7 @@ namespace osu.Game.Rulesets.Osu.Edit
// however it's still possible to achieve that flip by combining multiple flips over the other axes.
flipAxis = direction == Direction.Vertical
? GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 390) % 60 + 60))
- : GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 390) % 60 - 60));
+ : GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 360) % 60 - 30));
break;
}
}
From bae9625b0b4785b83124bfd38ccd8ff85d74947b Mon Sep 17 00:00:00 2001
From: StanR
Date: Fri, 19 Jul 2024 10:13:50 +0500
Subject: [PATCH 140/924] Make repetition nerf harsher, buff initial rhythm
ratio, small refactoring
---
.../Difficulty/Evaluators/RhythmEvaluator.cs | 28 ++++++++++---------
1 file changed, 15 insertions(+), 13 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
index 60bc53e7a1..9c48af80a7 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
@@ -32,7 +32,14 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
Deltas.Add(existingDelta == default ? delta : existingDelta);
}
- public double AverageDelta() => Math.Max(Deltas.Average(), OsuDifficultyHitObject.MIN_DELTA_TIME);
+ public double AverageDelta() => Deltas.Count > 0 ? Math.Max(Deltas.Average(), OsuDifficultyHitObject.MIN_DELTA_TIME) : 0;
+
+ public bool IsSimilarPolarity(Island other, double epsilon)
+ {
+ // consider islands to be of similar polarity only if they're having the same average delta (we don't want to consider 3 singletaps similar to a triple)
+ return Math.Abs(AverageDelta() - other.AverageDelta()) < epsilon &&
+ Deltas.Count % 2 == other.Deltas.Count % 2;
+ }
public override int GetHashCode()
{
@@ -53,7 +60,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
}
private const int history_time_max = 5 * 1000; // 5 seconds of calculatingRhythmBonus max.
- private const double rhythm_multiplier = 1.14;
+ private const double rhythm_multiplier = 1.05;
private const int max_island_size = 7;
///
@@ -61,8 +68,6 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
///
public static double EvaluateDifficultyOf(DifficultyHitObject current)
{
- Dictionary islandCounts = new Dictionary();
-
if (current.BaseObject is Spinner)
return 0;
@@ -70,6 +75,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
var island = new Island();
var previousIsland = new Island();
+ Dictionary islandCounts = new Dictionary();
double startRatio = 0; // store the ratio of the current start of an island to buff for tighter rhythms
@@ -97,7 +103,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
double prevDelta = prevObj.StrainTime;
double lastDelta = lastObj.StrainTime;
- double currRatio = 1.0 + 6.0 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
+ double currRatio = 1.0 + 10.0 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - currObj.HitWindowGreat * 0.3) / (currObj.HitWindowGreat * 0.3));
@@ -125,23 +131,19 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
if (prevObj.BaseObject is Slider) // bpm change was from a slider, this is easier typically than circle -> circle
effectiveRatio *= 0.25;
- if (previousIsland.Deltas.Count % 2 == island.Deltas.Count % 2) // repeated island polartiy (2 -> 4, 3 -> 5)
+ if (island.IsSimilarPolarity(previousIsland, deltaDifferenceEpsilon)) // repeated island polartiy (2 -> 4, 3 -> 5)
effectiveRatio *= 0.50;
if (lastDelta > prevDelta + deltaDifferenceEpsilon && prevDelta > currDelta + deltaDifferenceEpsilon) // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
effectiveRatio *= 0.125;
- if (islandCounts.ContainsKey(island))
+ if (!islandCounts.TryAdd(island, 1))
{
islandCounts[island]++;
// repeated island (ex: triplet -> triplet)
- double power = Math.Max(0.75, logistic(island.AverageDelta(), 3, 0.15, 9));
- effectiveRatio *= Math.Pow(1.0 / islandCounts[island], power);
- }
- else
- {
- islandCounts.Add(island, 1);
+ double power = logistic(island.AverageDelta(), 4, 0.165, 10);
+ effectiveRatio *= Math.Min(1.0 / islandCounts[island], Math.Pow(1.0 / islandCounts[island], power));
}
rhythmComplexitySum += Math.Sqrt(effectiveRatio * startRatio) * currHistoricalDecay;
From c1532bcb570ae36d7a73d5b42e451b8c7325b111 Mon Sep 17 00:00:00 2001
From: StanR
Date: Fri, 19 Jul 2024 11:01:42 +0500
Subject: [PATCH 141/924] Reduce base ratio a bit
---
osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
index 9c48af80a7..ba77bc6a61 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
double prevDelta = prevObj.StrainTime;
double lastDelta = lastObj.StrainTime;
- double currRatio = 1.0 + 10.0 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
+ double currRatio = 1.0 + 8.0 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - currObj.HitWindowGreat * 0.3) / (currObj.HitWindowGreat * 0.3));
From 3acd00b9b703a0a5a7445192eabac94bfe385594 Mon Sep 17 00:00:00 2001
From: StanR
Date: Sat, 10 Aug 2024 22:30:24 +0500
Subject: [PATCH 142/924] Tweak some values
---
.../Difficulty/Evaluators/RhythmEvaluator.cs | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
index ba77bc6a61..d2f58925cd 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
@@ -60,7 +60,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
}
private const int history_time_max = 5 * 1000; // 5 seconds of calculatingRhythmBonus max.
- private const double rhythm_multiplier = 1.05;
+ private const double rhythm_multiplier = 1.1;
private const int max_island_size = 7;
///
@@ -103,7 +103,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
double prevDelta = prevObj.StrainTime;
double lastDelta = lastObj.StrainTime;
- double currRatio = 1.0 + 8.0 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
+ double currRatio = 1.0 + 8.4 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - currObj.HitWindowGreat * 0.3) / (currObj.HitWindowGreat * 0.3));
@@ -132,7 +132,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
effectiveRatio *= 0.25;
if (island.IsSimilarPolarity(previousIsland, deltaDifferenceEpsilon)) // repeated island polartiy (2 -> 4, 3 -> 5)
- effectiveRatio *= 0.50;
+ effectiveRatio *= 0.35;
if (lastDelta > prevDelta + deltaDifferenceEpsilon && prevDelta > currDelta + deltaDifferenceEpsilon) // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
effectiveRatio *= 0.125;
From b18706274784430b26526fc4b3eecb75c8ef058e Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Tue, 13 Aug 2024 12:58:52 +0200
Subject: [PATCH 143/924] clarify meaning of flip axis vector
---
osu.Game/Utils/GeometryUtils.cs | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/osu.Game/Utils/GeometryUtils.cs b/osu.Game/Utils/GeometryUtils.cs
index 5a8ca9722e..810eda9950 100644
--- a/osu.Game/Utils/GeometryUtils.cs
+++ b/osu.Game/Utils/GeometryUtils.cs
@@ -51,6 +51,9 @@ namespace osu.Game.Utils
/// Given a flip direction, a surrounding quad for all selected objects, and a position,
/// will return the flipped position in screen space coordinates.
///
+ /// The direction to flip towards.
+ /// The quad surrounding all selected objects. The center of this determines the position of the axis.
+ /// The position to flip.
public static Vector2 GetFlippedPosition(Direction direction, Quad quad, Vector2 position)
{
var centre = quad.Centre;
@@ -73,6 +76,9 @@ namespace osu.Game.Utils
/// Given a flip axis vector, a surrounding quad for all selected objects, and a position,
/// will return the flipped position in screen space coordinates.
///
+ /// The vector indicating the direction to flip towards. This is perpendicular to the mirroring axis.
+ /// The quad surrounding all selected objects. The center of this determines the position of the axis.
+ /// The position to flip.
public static Vector2 GetFlippedPosition(Vector2 axis, Quad quad, Vector2 position)
{
var centre = quad.Centre;
From ae47671d17e6322a688f24a090020f6188539c1e Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Tue, 13 Aug 2024 14:21:42 +0200
Subject: [PATCH 144/924] clarify angle ranges in HandleFlip
---
osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
index da98da5238..bac0a5e273 100644
--- a/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
+++ b/osu.Game.Rulesets.Osu/Edit/OsuSelectionHandler.cs
@@ -138,15 +138,17 @@ namespace osu.Game.Rulesets.Osu.Edit
switch (gridToolbox.GridType.Value)
{
case PositionSnapGridType.Square:
- flipAxis = GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 405) % 90 - 45));
+ flipAxis = GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 360 + 45) % 90 - 45));
flipAxis = direction == Direction.Vertical ? flipAxis.PerpendicularLeft : flipAxis;
break;
case PositionSnapGridType.Triangle:
// Hex grid has 3 axes, so you can not directly flip over one of the axes,
// however it's still possible to achieve that flip by combining multiple flips over the other axes.
+ // Angle degree range for vertical = (-120, -60]
+ // Angle degree range for horizontal = [-30, 30)
flipAxis = direction == Direction.Vertical
- ? GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 390) % 60 + 60))
+ ? GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 360 + 30) % 60 + 60))
: GeometryUtils.RotateVector(Vector2.UnitX, -((gridToolbox.GridLinesRotation.Value + 360) % 60 - 30));
break;
}
From 2abcdd006466fdb291d9b727fb85b34a505155f7 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Tue, 13 Aug 2024 22:05:01 +0200
Subject: [PATCH 145/924] Redesign sample bank toggles
---
.../Rulesets/Edit/ExpandableSpriteText.cs | 34 ++++++++
osu.Game/Rulesets/Edit/HitObjectComposer.cs | 83 ++++++++++++++-----
.../DoubleDrawableTernaryButton.cs | 78 +++++++++++++++++
.../TernaryButtons/DrawableTernaryButton.cs | 10 +--
.../Components/ComposeBlueprintContainer.cs | 27 ++----
5 files changed, 185 insertions(+), 47 deletions(-)
create mode 100644 osu.Game/Rulesets/Edit/ExpandableSpriteText.cs
create mode 100644 osu.Game/Screens/Edit/Components/TernaryButtons/DoubleDrawableTernaryButton.cs
diff --git a/osu.Game/Rulesets/Edit/ExpandableSpriteText.cs b/osu.Game/Rulesets/Edit/ExpandableSpriteText.cs
new file mode 100644
index 0000000000..b45fce1d22
--- /dev/null
+++ b/osu.Game/Rulesets/Edit/ExpandableSpriteText.cs
@@ -0,0 +1,34 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Rulesets.Edit
+{
+ internal partial class ExpandableSpriteText : OsuSpriteText, IExpandable
+ {
+ public BindableBool Expanded { get; } = new BindableBool();
+
+ [Resolved(canBeNull: true)]
+ private IExpandingContainer? expandingContainer { get; set; }
+
+ protected override void LoadComplete()
+ {
+ base.LoadComplete();
+
+ expandingContainer?.Expanded.BindValueChanged(containerExpanded =>
+ {
+ Expanded.Value = containerExpanded.NewValue;
+ }, true);
+
+ Expanded.BindValueChanged(expanded =>
+ {
+ this.FadeTo(expanded.NewValue ? 1 : 0, 150, Easing.OutQuint);
+ }, true);
+ }
+ }
+}
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index 1319fb3352..e5b118004c 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -18,6 +18,7 @@ using osu.Framework.Input.Events;
using osu.Framework.Logging;
using osu.Game.Beatmaps;
using osu.Game.Configuration;
+using osu.Game.Graphics;
using osu.Game.Overlays;
using osu.Game.Rulesets.Configuration;
using osu.Game.Rulesets.Edit.Tools;
@@ -85,7 +86,6 @@ namespace osu.Game.Rulesets.Edit
private EditorRadioButtonCollection toolboxCollection;
private FillFlowContainer togglesCollection;
private FillFlowContainer sampleBankTogglesCollection;
- private FillFlowContainer sampleAdditionBankTogglesCollection;
private IBindable hasTiming;
private Bindable autoSeekOnPlacement;
@@ -176,25 +176,55 @@ namespace osu.Game.Rulesets.Edit
Spacing = new Vector2(0, 5),
},
},
- new EditorToolboxGroup("bank (Shift-Q~R)")
+ new EditorToolboxGroup("bank (Shift/Alt-Q~R)")
{
- Child = sampleBankTogglesCollection = new FillFlowContainer
+ Child = new FillFlowContainer
{
RelativeSizeAxes = Axes.X,
AutoSizeAxes = Axes.Y,
Direction = FillDirection.Vertical,
Spacing = new Vector2(0, 5),
- },
- },
- new EditorToolboxGroup("additions (Alt-Q~R)")
- {
- Child = sampleAdditionBankTogglesCollection = new FillFlowContainer
- {
- RelativeSizeAxes = Axes.X,
- AutoSizeAxes = Axes.Y,
- Direction = FillDirection.Vertical,
- Spacing = new Vector2(0, 5),
- },
+ Children = new Drawable[]
+ {
+ new Container
+ {
+ RelativeSizeAxes = Axes.X,
+ AutoSizeAxes = Axes.Y,
+ Children = new Drawable[]
+ {
+ new ExpandableSpriteText
+ {
+ Text = "Normal",
+ AlwaysPresent = true,
+ AllowMultiline = false,
+ RelativePositionAxes = Axes.X,
+ X = 0.25f,
+ Origin = Anchor.TopCentre,
+ Anchor = Anchor.TopLeft,
+ Font = OsuFont.GetFont(weight: FontWeight.Regular, size: 17),
+ },
+ new ExpandableSpriteText
+ {
+ Text = "Addition",
+ AlwaysPresent = true,
+ AllowMultiline = false,
+ RelativePositionAxes = Axes.X,
+ X = 0.75f,
+ Origin = Anchor.TopCentre,
+ Anchor = Anchor.TopLeft,
+ Font = OsuFont.GetFont(weight: FontWeight.Regular, size: 17),
+ },
+ }
+ },
+ sampleBankTogglesCollection = new FillFlowContainer
+ {
+ RelativeSizeAxes = Axes.X,
+ AutoSizeAxes = Axes.Y,
+ Direction = FillDirection.Vertical,
+ Spacing = new Vector2(0, 5),
+ },
+ }
+ }
},
}
},
@@ -240,8 +270,7 @@ namespace osu.Game.Rulesets.Edit
TernaryStates = CreateTernaryButtons().ToArray();
togglesCollection.AddRange(TernaryStates.Select(b => new DrawableTernaryButton(b)));
- sampleBankTogglesCollection.AddRange(BlueprintContainer.SampleBankTernaryStates.Select(b => new DrawableTernaryButton(b)));
- sampleAdditionBankTogglesCollection.AddRange(BlueprintContainer.SampleAdditionBankTernaryStates.Select(b => new DrawableTernaryButton(b)));
+ sampleBankTogglesCollection.AddRange(BlueprintContainer.SampleBankTernaryStates.Zip(BlueprintContainer.SampleAdditionBankTernaryStates).Select(b => new DoubleDrawableTernaryButton(b.First, b.Second)));
setSelectTool();
@@ -397,7 +426,7 @@ namespace osu.Game.Rulesets.Edit
attemptToggle(rightIndex, sampleBankTogglesCollection);
if (e.AltPressed)
- attemptToggle(rightIndex, sampleAdditionBankTogglesCollection);
+ attemptToggle(rightIndex, sampleBankTogglesCollection, true);
}
else
attemptToggle(rightIndex, togglesCollection);
@@ -405,14 +434,26 @@ namespace osu.Game.Rulesets.Edit
return handled || base.OnKeyDown(e);
- void attemptToggle(int index, FillFlowContainer collection)
+ void attemptToggle(int index, FillFlowContainer collection, bool second = false)
{
var item = collection.ElementAtOrDefault(index);
- if (item is DrawableTernaryButton button)
+ switch (item)
{
- button.Button.Toggle();
- handled = true;
+ case DrawableTernaryButton button:
+ button.Button.Toggle();
+ handled = true;
+ break;
+
+ case DoubleDrawableTernaryButton doubleButton:
+ {
+ if (second)
+ doubleButton.Button2.Toggle();
+ else
+ doubleButton.Button1.Toggle();
+ handled = true;
+ break;
+ }
}
}
}
diff --git a/osu.Game/Screens/Edit/Components/TernaryButtons/DoubleDrawableTernaryButton.cs b/osu.Game/Screens/Edit/Components/TernaryButtons/DoubleDrawableTernaryButton.cs
new file mode 100644
index 0000000000..44b5d10b9e
--- /dev/null
+++ b/osu.Game/Screens/Edit/Components/TernaryButtons/DoubleDrawableTernaryButton.cs
@@ -0,0 +1,78 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics.Sprites;
+
+namespace osu.Game.Screens.Edit.Components.TernaryButtons
+{
+ public partial class DoubleDrawableTernaryButton : CompositeDrawable
+ {
+ public readonly TernaryButton Button1;
+ public readonly TernaryButton Button2;
+
+ public DoubleDrawableTernaryButton(TernaryButton button1, TernaryButton button2)
+ {
+ Button1 = button1;
+ Button2 = button2;
+ }
+
+ [BackgroundDependencyLoader]
+ private void load()
+ {
+ RelativeSizeAxes = Axes.X;
+ AutoSizeAxes = Axes.Y;
+ Masking = true;
+ CornerRadius = 5;
+
+ InternalChildren = new Drawable[]
+ {
+ new Container
+ {
+ RelativeSizeAxes = Axes.X,
+ AutoSizeAxes = Axes.Y,
+ Width = 0.5f,
+ Padding = new MarginPadding { Right = 1 },
+ Child = new InlineDrawableTernaryButton(Button1),
+ },
+ new Container
+ {
+ Anchor = Anchor.TopRight,
+ Origin = Anchor.TopRight,
+ RelativeSizeAxes = Axes.X,
+ AutoSizeAxes = Axes.Y,
+ Width = 0.5f,
+ Padding = new MarginPadding { Left = 1 },
+ Child = new InlineDrawableTernaryButton(Button2),
+ },
+ };
+ }
+ }
+
+ public partial class InlineDrawableTernaryButton : DrawableTernaryButton
+ {
+ public InlineDrawableTernaryButton(TernaryButton button)
+ : base(button)
+ {
+ }
+
+ [BackgroundDependencyLoader]
+ private void load()
+ {
+ Content.Masking = false;
+ Content.CornerRadius = 0;
+ Icon.X = 4.5f;
+ }
+
+ protected override SpriteText CreateText() => new OsuSpriteText
+ {
+ Depth = -1,
+ Origin = Anchor.CentreLeft,
+ Anchor = Anchor.CentreLeft,
+ X = 31f
+ };
+ }
+}
diff --git a/osu.Game/Screens/Edit/Components/TernaryButtons/DrawableTernaryButton.cs b/osu.Game/Screens/Edit/Components/TernaryButtons/DrawableTernaryButton.cs
index 95d5dd36d8..d3fd701406 100644
--- a/osu.Game/Screens/Edit/Components/TernaryButtons/DrawableTernaryButton.cs
+++ b/osu.Game/Screens/Edit/Components/TernaryButtons/DrawableTernaryButton.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Screens.Edit.Components.TernaryButtons
private Color4 selectedBackgroundColour;
private Color4 selectedIconColour;
- private Drawable icon = null!;
+ protected Drawable Icon = null!;
public readonly TernaryButton Button;
@@ -43,7 +43,7 @@ namespace osu.Game.Screens.Edit.Components.TernaryButtons
defaultIconColour = defaultBackgroundColour.Darken(0.5f);
selectedIconColour = selectedBackgroundColour.Lighten(0.5f);
- Add(icon = (Button.CreateIcon?.Invoke() ?? new Circle()).With(b =>
+ Add(Icon = (Button.CreateIcon?.Invoke() ?? new Circle()).With(b =>
{
b.Blending = BlendingParameters.Additive;
b.Anchor = Anchor.CentreLeft;
@@ -75,17 +75,17 @@ namespace osu.Game.Screens.Edit.Components.TernaryButtons
switch (Button.Bindable.Value)
{
case TernaryState.Indeterminate:
- icon.Colour = selectedIconColour.Darken(0.5f);
+ Icon.Colour = selectedIconColour.Darken(0.5f);
BackgroundColour = selectedBackgroundColour.Darken(0.5f);
break;
case TernaryState.False:
- icon.Colour = defaultIconColour;
+ Icon.Colour = defaultIconColour;
BackgroundColour = defaultBackgroundColour;
break;
case TernaryState.True:
- icon.Colour = selectedIconColour;
+ Icon.Colour = selectedIconColour;
BackgroundColour = selectedBackgroundColour;
break;
}
diff --git a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
index 4c1610902e..9f2fff9ca3 100644
--- a/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/ComposeBlueprintContainer.cs
@@ -259,28 +259,13 @@ namespace osu.Game.Screens.Edit.Compose.Components
private Drawable getIconForBank(string sampleName)
{
- return new Container
+ return new OsuSpriteText
{
- Size = new Vector2(30, 20),
- Children = new Drawable[]
- {
- new SpriteIcon
- {
- Size = new Vector2(8),
- Anchor = Anchor.CentreLeft,
- Origin = Anchor.CentreLeft,
- Icon = FontAwesome.Solid.VolumeOff
- },
- new OsuSpriteText
- {
- Anchor = Anchor.CentreLeft,
- Origin = Anchor.CentreLeft,
- X = 10,
- Y = -1,
- Font = OsuFont.Default.With(weight: FontWeight.Bold, size: 20),
- Text = $"{char.ToUpperInvariant(sampleName.First())}"
- }
- }
+ Anchor = Anchor.Centre,
+ Origin = Anchor.Centre,
+ Y = -1,
+ Font = OsuFont.Default.With(weight: FontWeight.Bold, size: 20),
+ Text = $"{char.ToUpperInvariant(sampleName.First())}"
};
}
From 10f2ac64905784c22db6d36d8a9f7ae571e8164d Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Tue, 13 Aug 2024 22:13:17 +0200
Subject: [PATCH 146/924] fix anti-aliased white leaking out of the button
---
.../Components/TernaryButtons/DoubleDrawableTernaryButton.cs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/osu.Game/Screens/Edit/Components/TernaryButtons/DoubleDrawableTernaryButton.cs b/osu.Game/Screens/Edit/Components/TernaryButtons/DoubleDrawableTernaryButton.cs
index 44b5d10b9e..2cf3b760f7 100644
--- a/osu.Game/Screens/Edit/Components/TernaryButtons/DoubleDrawableTernaryButton.cs
+++ b/osu.Game/Screens/Edit/Components/TernaryButtons/DoubleDrawableTernaryButton.cs
@@ -5,7 +5,7 @@ using osu.Framework.Allocation;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Sprites;
-using osu.Game.Graphics.Sprites;
+using osu.Game.Rulesets.Edit;
namespace osu.Game.Screens.Edit.Components.TernaryButtons
{
@@ -67,7 +67,7 @@ namespace osu.Game.Screens.Edit.Components.TernaryButtons
Icon.X = 4.5f;
}
- protected override SpriteText CreateText() => new OsuSpriteText
+ protected override SpriteText CreateText() => new ExpandableSpriteText
{
Depth = -1,
Origin = Anchor.CentreLeft,
From 55e9bb6a5da9ccbfed949890b492f2620e5dcfab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?=
Date: Mon, 19 Aug 2024 10:59:47 +0200
Subject: [PATCH 147/924] Privatise setter
---
.../Edit/Components/TernaryButtons/DrawableTernaryButton.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game/Screens/Edit/Components/TernaryButtons/DrawableTernaryButton.cs b/osu.Game/Screens/Edit/Components/TernaryButtons/DrawableTernaryButton.cs
index d3fd701406..9e528aa21b 100644
--- a/osu.Game/Screens/Edit/Components/TernaryButtons/DrawableTernaryButton.cs
+++ b/osu.Game/Screens/Edit/Components/TernaryButtons/DrawableTernaryButton.cs
@@ -21,7 +21,7 @@ namespace osu.Game.Screens.Edit.Components.TernaryButtons
private Color4 selectedBackgroundColour;
private Color4 selectedIconColour;
- protected Drawable Icon = null!;
+ protected Drawable Icon { get; private set; } = null!;
public readonly TernaryButton Button;
From 32821be0462a56f7b64b037f8e6ab291e584205e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?=
Date: Mon, 19 Aug 2024 11:07:34 +0200
Subject: [PATCH 148/924] Make "double ternary button" specific to samples
We can generalise *when* there is the need to generalise. So far the
generalisation only looked like *obfuscation*.
---
osu.Game/Rulesets/Edit/HitObjectComposer.cs | 42 +++++---------
...ryButton.cs => SampleBankTernaryButton.cs} | 58 +++++++++----------
2 files changed, 44 insertions(+), 56 deletions(-)
rename osu.Game/Screens/Edit/Components/TernaryButtons/{DoubleDrawableTernaryButton.cs => SampleBankTernaryButton.cs} (52%)
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index e5b118004c..f9b218a429 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -270,7 +270,7 @@ namespace osu.Game.Rulesets.Edit
TernaryStates = CreateTernaryButtons().ToArray();
togglesCollection.AddRange(TernaryStates.Select(b => new DrawableTernaryButton(b)));
- sampleBankTogglesCollection.AddRange(BlueprintContainer.SampleBankTernaryStates.Zip(BlueprintContainer.SampleAdditionBankTernaryStates).Select(b => new DoubleDrawableTernaryButton(b.First, b.Second)));
+ sampleBankTogglesCollection.AddRange(BlueprintContainer.SampleBankTernaryStates.Zip(BlueprintContainer.SampleAdditionBankTernaryStates).Select(b => new SampleBankTernaryButton(b.First, b.Second)));
setSelectTool();
@@ -422,40 +422,28 @@ namespace osu.Game.Rulesets.Edit
{
if (e.ShiftPressed || e.AltPressed)
{
- if (e.ShiftPressed)
- attemptToggle(rightIndex, sampleBankTogglesCollection);
+ if (sampleBankTogglesCollection.ElementAtOrDefault(rightIndex) is SampleBankTernaryButton sampleBankTernaryButton)
+ {
+ if (e.ShiftPressed)
+ sampleBankTernaryButton.NormalButton.Toggle();
- if (e.AltPressed)
- attemptToggle(rightIndex, sampleBankTogglesCollection, true);
+ if (e.AltPressed)
+ sampleBankTernaryButton.AdditionsButton.Toggle();
+
+ return true;
+ }
}
else
- attemptToggle(rightIndex, togglesCollection);
- }
-
- return handled || base.OnKeyDown(e);
-
- void attemptToggle(int index, FillFlowContainer collection, bool second = false)
- {
- var item = collection.ElementAtOrDefault(index);
-
- switch (item)
{
- case DrawableTernaryButton button:
- button.Button.Toggle();
- handled = true;
- break;
-
- case DoubleDrawableTernaryButton doubleButton:
+ if (togglesCollection.ElementAtOrDefault(rightIndex) is DrawableTernaryButton button)
{
- if (second)
- doubleButton.Button2.Toggle();
- else
- doubleButton.Button1.Toggle();
- handled = true;
- break;
+ button.Button.Toggle();
+ return true;
}
}
}
+
+ return base.OnKeyDown(e);
}
private bool checkLeftToggleFromKey(Key key, out int index)
diff --git a/osu.Game/Screens/Edit/Components/TernaryButtons/DoubleDrawableTernaryButton.cs b/osu.Game/Screens/Edit/Components/TernaryButtons/SampleBankTernaryButton.cs
similarity index 52%
rename from osu.Game/Screens/Edit/Components/TernaryButtons/DoubleDrawableTernaryButton.cs
rename to osu.Game/Screens/Edit/Components/TernaryButtons/SampleBankTernaryButton.cs
index 2cf3b760f7..33eb2ac0b4 100644
--- a/osu.Game/Screens/Edit/Components/TernaryButtons/DoubleDrawableTernaryButton.cs
+++ b/osu.Game/Screens/Edit/Components/TernaryButtons/SampleBankTernaryButton.cs
@@ -9,15 +9,15 @@ using osu.Game.Rulesets.Edit;
namespace osu.Game.Screens.Edit.Components.TernaryButtons
{
- public partial class DoubleDrawableTernaryButton : CompositeDrawable
+ public partial class SampleBankTernaryButton : CompositeDrawable
{
- public readonly TernaryButton Button1;
- public readonly TernaryButton Button2;
+ public readonly TernaryButton NormalButton;
+ public readonly TernaryButton AdditionsButton;
- public DoubleDrawableTernaryButton(TernaryButton button1, TernaryButton button2)
+ public SampleBankTernaryButton(TernaryButton normalButton, TernaryButton additionsButton)
{
- Button1 = button1;
- Button2 = button2;
+ NormalButton = normalButton;
+ AdditionsButton = additionsButton;
}
[BackgroundDependencyLoader]
@@ -36,7 +36,7 @@ namespace osu.Game.Screens.Edit.Components.TernaryButtons
AutoSizeAxes = Axes.Y,
Width = 0.5f,
Padding = new MarginPadding { Right = 1 },
- Child = new InlineDrawableTernaryButton(Button1),
+ Child = new InlineDrawableTernaryButton(NormalButton),
},
new Container
{
@@ -46,33 +46,33 @@ namespace osu.Game.Screens.Edit.Components.TernaryButtons
AutoSizeAxes = Axes.Y,
Width = 0.5f,
Padding = new MarginPadding { Left = 1 },
- Child = new InlineDrawableTernaryButton(Button2),
+ Child = new InlineDrawableTernaryButton(AdditionsButton),
},
};
}
- }
- public partial class InlineDrawableTernaryButton : DrawableTernaryButton
- {
- public InlineDrawableTernaryButton(TernaryButton button)
- : base(button)
+ private partial class InlineDrawableTernaryButton : DrawableTernaryButton
{
+ public InlineDrawableTernaryButton(TernaryButton button)
+ : base(button)
+ {
+ }
+
+ [BackgroundDependencyLoader]
+ private void load()
+ {
+ Content.Masking = false;
+ Content.CornerRadius = 0;
+ Icon.X = 4.5f;
+ }
+
+ protected override SpriteText CreateText() => new ExpandableSpriteText
+ {
+ Depth = -1,
+ Origin = Anchor.CentreLeft,
+ Anchor = Anchor.CentreLeft,
+ X = 31f
+ };
}
-
- [BackgroundDependencyLoader]
- private void load()
- {
- Content.Masking = false;
- Content.CornerRadius = 0;
- Icon.X = 4.5f;
- }
-
- protected override SpriteText CreateText() => new ExpandableSpriteText
- {
- Depth = -1,
- Origin = Anchor.CentreLeft,
- Anchor = Anchor.CentreLeft,
- X = 31f
- };
}
}
From 588a36cba39293497ec46c1106cd33525a87999c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?=
Date: Mon, 19 Aug 2024 14:58:12 +0200
Subject: [PATCH 149/924] Remove unused variable
---
osu.Game/Rulesets/Edit/HitObjectComposer.cs | 2 --
1 file changed, 2 deletions(-)
diff --git a/osu.Game/Rulesets/Edit/HitObjectComposer.cs b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
index f9b218a429..085740d3eb 100644
--- a/osu.Game/Rulesets/Edit/HitObjectComposer.cs
+++ b/osu.Game/Rulesets/Edit/HitObjectComposer.cs
@@ -404,8 +404,6 @@ namespace osu.Game.Rulesets.Edit
if (e.ControlPressed || e.SuperPressed)
return false;
- bool handled = false;
-
if (checkLeftToggleFromKey(e.Key, out int leftIndex))
{
var item = toolboxCollection.Items.ElementAtOrDefault(leftIndex);
From 09ca190b8ddb44d27b16763f6a6c19d71332e001 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Wed, 21 Aug 2024 00:10:15 +0200
Subject: [PATCH 150/924] re-implement ConvexHull 100% original
---
osu.Game/Utils/GeometryUtils.cs | 39 +++++++++++++++++++--------------
1 file changed, 22 insertions(+), 17 deletions(-)
diff --git a/osu.Game/Utils/GeometryUtils.cs b/osu.Game/Utils/GeometryUtils.cs
index 810eda9950..d4c1dc2db7 100644
--- a/osu.Game/Utils/GeometryUtils.cs
+++ b/osu.Game/Utils/GeometryUtils.cs
@@ -154,33 +154,38 @@ namespace osu.Game.Utils
{
List p = points.ToList();
- if (p.Count <= 1)
+ if (p.Count < 3)
return p;
- int n = p.Count, k = 0;
- List hull = new List(new Vector2[2 * n]);
-
p.Sort((a, b) => a.X == b.X ? a.Y.CompareTo(b.Y) : a.X.CompareTo(b.X));
- // Build lower hull
- for (int i = 0; i < n; ++i)
+ List upper = new List();
+ List lower = new List();
+
+ // Build the lower hull
+ for (int i = 0; i < p.Count; i++)
{
- while (k >= 2 && cross(hull[k - 2], hull[k - 1], p[i]) <= 0)
- k--;
- hull[k] = p[i];
- k++;
+ while (lower.Count >= 2 && cross(lower[^2], lower[^1], p[i]) <= 0)
+ lower.RemoveAt(lower.Count - 1);
+
+ lower.Add(p[i]);
}
- // Build upper hull
- for (int i = n - 2, t = k + 1; i >= 0; i--)
+ // Build the upper hull
+ for (int i = p.Count - 1; i >= 0; i--)
{
- while (k >= t && cross(hull[k - 2], hull[k - 1], p[i]) <= 0)
- k--;
- hull[k] = p[i];
- k++;
+ while (upper.Count >= 2 && cross(upper[^2], upper[^1], p[i]) <= 0)
+ upper.RemoveAt(upper.Count - 1);
+
+ upper.Add(p[i]);
}
- return hull.Take(k - 1).ToList();
+ // Remove the last point of each half because it's a duplicate of the first point of the other half
+ lower.RemoveAt(lower.Count - 1);
+ upper.RemoveAt(upper.Count - 1);
+
+ lower.AddRange(upper);
+ return lower;
float cross(Vector2 o, Vector2 a, Vector2 b) => (a.X - o.X) * (b.Y - o.Y) - (a.Y - o.Y) * (b.X - o.X);
}
From ff3bffc7d9e0e955afe3ad3ad498c2d3259e6877 Mon Sep 17 00:00:00 2001
From: OliBomby
Date: Wed, 21 Aug 2024 00:30:57 +0200
Subject: [PATCH 151/924] add test
---
osu.Game.Tests/Utils/GeometryUtilsTest.cs | 33 +++++++++++++++++++++++
1 file changed, 33 insertions(+)
create mode 100644 osu.Game.Tests/Utils/GeometryUtilsTest.cs
diff --git a/osu.Game.Tests/Utils/GeometryUtilsTest.cs b/osu.Game.Tests/Utils/GeometryUtilsTest.cs
new file mode 100644
index 0000000000..ded4656ac1
--- /dev/null
+++ b/osu.Game.Tests/Utils/GeometryUtilsTest.cs
@@ -0,0 +1,33 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Game.Utils;
+using osuTK;
+
+namespace osu.Game.Tests.Utils
+{
+ [TestFixture]
+ public class GeometryUtilsTest
+ {
+ [TestCase(new int[] { }, new int[] { })]
+ [TestCase(new[] { 0, 0 }, new[] { 0, 0 })]
+ [TestCase(new[] { 0, 0, 1, 1, 1, -1, 2, 0 }, new[] { 0, 0, 1, 1, 2, 0, 1, -1 })]
+ [TestCase(new[] { 0, 0, 1, 1, 1, -1, 2, 0, 1, 0 }, new[] { 0, 0, 1, 1, 2, 0, 1, -1 })]
+ [TestCase(new[] { 0, 0, 1, 1, 2, -1, 2, 0, 1, 0, 4, 10 }, new[] { 0, 0, 4, 10, 2, -1 })]
+ public void TestConvexHull(int[] values, int[] expected)
+ {
+ var points = new Vector2[values.Length / 2];
+ for (int i = 0; i < values.Length; i += 2)
+ points[i / 2] = new Vector2(values[i], values[i + 1]);
+
+ var expectedPoints = new Vector2[expected.Length / 2];
+ for (int i = 0; i < expected.Length; i += 2)
+ expectedPoints[i / 2] = new Vector2(expected[i], expected[i + 1]);
+
+ var hull = GeometryUtils.GetConvexHull(points);
+
+ Assert.That(hull, Is.EquivalentTo(expectedPoints));
+ }
+ }
+}
From f1adc6f98cc48024a0bb35811955fb5653c3fdf6 Mon Sep 17 00:00:00 2001
From: StanR
Date: Thu, 22 Aug 2024 15:59:13 +0500
Subject: [PATCH 152/924] Don't cap max island size, make repetition nerf more
lenient on high bpm, adjust balancing
---
.../Difficulty/Evaluators/RhythmEvaluator.cs | 14 +++++---------
1 file changed, 5 insertions(+), 9 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
index d2f58925cd..9ffb4fc3d7 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
@@ -60,8 +60,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
}
private const int history_time_max = 5 * 1000; // 5 seconds of calculatingRhythmBonus max.
- private const double rhythm_multiplier = 1.1;
- private const int max_island_size = 7;
+ private const double rhythm_multiplier = 1.05;
///
/// Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current .
@@ -103,7 +102,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
double prevDelta = prevObj.StrainTime;
double lastDelta = lastObj.StrainTime;
- double currRatio = 1.0 + 8.4 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
+ double currRatio = 1.0 + 8.8 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - currObj.HitWindowGreat * 0.3) / (currObj.HitWindowGreat * 0.3));
@@ -117,11 +116,8 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
{
if (!(Math.Abs(prevDelta - currDelta) > deltaDifferenceEpsilon))
{
- if (island.Deltas.Count < max_island_size)
- {
- // island is still progressing
- island.AddDelta((int)currDelta, deltaDifferenceEpsilon);
- }
+ // island is still progressing
+ island.AddDelta((int)currDelta, deltaDifferenceEpsilon);
}
else
{
@@ -143,7 +139,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
// repeated island (ex: triplet -> triplet)
double power = logistic(island.AverageDelta(), 4, 0.165, 10);
- effectiveRatio *= Math.Min(1.0 / islandCounts[island], Math.Pow(1.0 / islandCounts[island], power));
+ effectiveRatio *= Math.Min(2.0 / islandCounts[island], Math.Pow(1.0 / islandCounts[island], power));
}
rhythmComplexitySum += Math.Sqrt(effectiveRatio * startRatio) * currHistoricalDecay;
From ce8286d299f11a9e7c96baf67ca38d5a143239d5 Mon Sep 17 00:00:00 2001
From: StanR
Date: Sat, 24 Aug 2024 04:37:58 +0500
Subject: [PATCH 153/924] Scale difficulty with doubletapness, make kicksliders
not reduce the difficulty of the next object, adjust balancing
---
.../Difficulty/Evaluators/RhythmEvaluator.cs | 28 +++++++++++++------
.../Difficulty/Evaluators/SpeedEvaluator.cs | 14 +---------
.../Preprocessing/OsuDifficultyHitObject.cs | 18 ++++++++++++
3 files changed, 38 insertions(+), 22 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
index 9ffb4fc3d7..22b330bcac 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
@@ -60,7 +60,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
}
private const int history_time_max = 5 * 1000; // 5 seconds of calculatingRhythmBonus max.
- private const double rhythm_multiplier = 1.05;
+ private const double rhythm_multiplier = 0.95;
///
/// Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current .
@@ -102,7 +102,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
double prevDelta = prevObj.StrainTime;
double lastDelta = lastObj.StrainTime;
- double currRatio = 1.0 + 8.8 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
+ double currRatio = 1.0 + 9.8 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - currObj.HitWindowGreat * 0.3) / (currObj.HitWindowGreat * 0.3));
@@ -121,16 +121,22 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
}
else
{
- if (currObj.BaseObject is Slider) // bpm change is into slider, this is easy acc window
+ // bpm change is into slider, this is easy acc window
+ if (currObj.BaseObject is Slider)
effectiveRatio *= 0.125;
- if (prevObj.BaseObject is Slider) // bpm change was from a slider, this is easier typically than circle -> circle
- effectiveRatio *= 0.25;
+ // bpm change was from a slider, this is easier typically than circle -> circle
+ // unintentional side effect is that bursts with kicksliders at the ends might have lower difficulty than bursts without sliders
+ // therefore we're checking for quick sliders and don't lower the difficulty for them since they don't really make tapping easier (no time to adjust)
+ if (prevObj.BaseObject is Slider && prevObj.TravelTime > prevDelta * 1.5)
+ effectiveRatio *= 0.15;
- if (island.IsSimilarPolarity(previousIsland, deltaDifferenceEpsilon)) // repeated island polartiy (2 -> 4, 3 -> 5)
- effectiveRatio *= 0.35;
+ // repeated island polartiy (2 -> 4, 3 -> 5)
+ if (island.IsSimilarPolarity(previousIsland, deltaDifferenceEpsilon))
+ effectiveRatio *= 0.3;
- if (lastDelta > prevDelta + deltaDifferenceEpsilon && prevDelta > currDelta + deltaDifferenceEpsilon) // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
+ // previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
+ if (lastDelta > prevDelta + deltaDifferenceEpsilon && prevDelta > currDelta + deltaDifferenceEpsilon)
effectiveRatio *= 0.125;
if (!islandCounts.TryAdd(island, 1))
@@ -142,6 +148,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
effectiveRatio *= Math.Min(2.0 / islandCounts[island], Math.Pow(1.0 / islandCounts[island], power));
}
+ // scale down the difficulty if the object is doubletappable
+ double doubletapness = prevObj.GetDoubletapness((OsuDifficultyHitObject?)prevObj.Next(0));
+ effectiveRatio *= 1 - doubletapness * 0.75;
+
rhythmComplexitySum += Math.Sqrt(effectiveRatio * startRatio) * currHistoricalDecay;
startRatio = effectiveRatio;
@@ -167,7 +177,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
prevObj = currObj;
}
- return Math.Sqrt(4 + rhythmComplexitySum * rhythm_multiplier) / 2; //produces multiplier that can be applied to strain. range [1, infinity) (not really though)
+ return Math.Sqrt(4 + rhythmComplexitySum * rhythm_multiplier) / 2.0; //produces multiplier that can be applied to strain. range [1, infinity) (not really though)
}
private static double logistic(double x, double maxValue, double multiplier, double offset) => (maxValue / (1 + Math.Pow(Math.E, offset - (multiplier * x))));
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs
index 2df383aaa8..3a264188f6 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/SpeedEvaluator.cs
@@ -30,21 +30,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
// derive strainTime for calculation
var osuCurrObj = (OsuDifficultyHitObject)current;
var osuPrevObj = current.Index > 0 ? (OsuDifficultyHitObject)current.Previous(0) : null;
- var osuNextObj = (OsuDifficultyHitObject?)current.Next(0);
double strainTime = osuCurrObj.StrainTime;
- double doubletapness = 1;
-
- // Nerf doubletappable doubles.
- if (osuNextObj != null)
- {
- double currDeltaTime = Math.Max(1, osuCurrObj.DeltaTime);
- double nextDeltaTime = Math.Max(1, osuNextObj.DeltaTime);
- double deltaDifference = Math.Abs(nextDeltaTime - currDeltaTime);
- double speedRatio = currDeltaTime / Math.Max(currDeltaTime, deltaDifference);
- double windowRatio = Math.Pow(Math.Min(1, currDeltaTime / osuCurrObj.HitWindowGreat), 2);
- doubletapness = Math.Pow(speedRatio, 1 - windowRatio);
- }
+ double doubletapness = 1.0 - osuCurrObj.GetDoubletapness((OsuDifficultyHitObject?)osuCurrObj.Next(0));
// Cap deltatime to the OD 300 hitwindow.
// 0.93 is derived from making sure 260bpm OD8 streams aren't nerfed harshly, whilst 0.92 limits the effect of the cap.
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs b/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs
index 95535274c1..3eaf500ad7 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs
@@ -137,6 +137,24 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
return Math.Clamp((time - fadeInStartTime) / fadeInDuration, 0.0, 1.0);
}
+ ///
+ /// Returns how possible is it to doubletap this object together with the next one and get perfect judgement in range from 0 to 1
+ ///
+ public double GetDoubletapness(OsuDifficultyHitObject? osuNextObj)
+ {
+ if (osuNextObj != null)
+ {
+ double currDeltaTime = Math.Max(1, DeltaTime);
+ double nextDeltaTime = Math.Max(1, osuNextObj.DeltaTime);
+ double deltaDifference = Math.Abs(nextDeltaTime - currDeltaTime);
+ double speedRatio = currDeltaTime / Math.Max(currDeltaTime, deltaDifference);
+ double windowRatio = Math.Pow(Math.Min(1, currDeltaTime / HitWindowGreat), 2);
+ return 1.0 - Math.Pow(speedRatio, 1 - windowRatio);
+ }
+
+ return 0;
+ }
+
private void setDistances(double clockRate)
{
if (BaseObject is Slider currentSlider)
From ed45c947fca29fd07439e1004ce17ec3069f9021 Mon Sep 17 00:00:00 2001
From: StanR
Date: Tue, 27 Aug 2024 15:50:08 +0500
Subject: [PATCH 154/924] Adjust max history by clockrate to make rhythm
calculation more consistent between rates
---
.../Difficulty/Evaluators/RhythmEvaluator.cs | 28 ++++++++++---------
.../Difficulty/OsuDifficultyCalculator.cs | 2 +-
.../Difficulty/Skills/Speed.cs | 6 ++--
3 files changed, 20 insertions(+), 16 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
index 22b330bcac..26f50efc72 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
@@ -60,12 +60,13 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
}
private const int history_time_max = 5 * 1000; // 5 seconds of calculatingRhythmBonus max.
- private const double rhythm_multiplier = 0.95;
+ private const int history_objects_max = 32;
+ private const double rhythm_multiplier = 1.25;
///
/// Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current .
///
- public static double EvaluateDifficultyOf(DifficultyHitObject current)
+ public static double EvaluateDifficultyOf(DifficultyHitObject current, double clockRate)
{
if (current.BaseObject is Spinner)
return 0;
@@ -76,15 +77,18 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
var previousIsland = new Island();
Dictionary islandCounts = new Dictionary();
+ int historyTimeMaxAdjusted = (int)Math.Ceiling(history_time_max / clockRate);
+ int historyObjectsMaxAdjusted = (int)Math.Ceiling(history_objects_max / clockRate);
+
double startRatio = 0; // store the ratio of the current start of an island to buff for tighter rhythms
bool firstDeltaSwitch = false;
- int historicalNoteCount = Math.Min(current.Index, 32);
+ int historicalNoteCount = Math.Min(current.Index, historyObjectsMaxAdjusted);
int rhythmStart = 0;
- while (rhythmStart < historicalNoteCount - 2 && current.StartTime - current.Previous(rhythmStart).StartTime < history_time_max)
+ while (rhythmStart < historicalNoteCount - 2 && current.StartTime - current.Previous(rhythmStart).StartTime < historyTimeMaxAdjusted)
rhythmStart++;
OsuDifficultyHitObject prevObj = (OsuDifficultyHitObject)current.Previous(rhythmStart);
@@ -94,7 +98,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
{
OsuDifficultyHitObject currObj = (OsuDifficultyHitObject)current.Previous(i - 1);
- double currHistoricalDecay = (history_time_max - (current.StartTime - currObj.StartTime)) / history_time_max; // scales note 0 to 1 from history to now
+ double currHistoricalDecay = (historyTimeMaxAdjusted - (current.StartTime - currObj.StartTime)) / historyTimeMaxAdjusted; // scales note 0 to 1 from history to now
currHistoricalDecay = Math.Min((double)(historicalNoteCount - i) / historicalNoteCount, currHistoricalDecay); // either we're limited by time or limited by object count.
@@ -102,16 +106,14 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
double prevDelta = prevObj.StrainTime;
double lastDelta = lastObj.StrainTime;
- double currRatio = 1.0 + 9.8 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
-
- double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - currObj.HitWindowGreat * 0.3) / (currObj.HitWindowGreat * 0.3));
-
- windowPenalty = Math.Min(1, windowPenalty);
-
- double effectiveRatio = windowPenalty * currRatio;
+ double currRatio = 1.0 + 7.27 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
double deltaDifferenceEpsilon = currObj.HitWindowGreat * 0.3;
+ double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - deltaDifferenceEpsilon) / deltaDifferenceEpsilon);
+
+ double effectiveRatio = windowPenalty * currRatio;
+
if (firstDeltaSwitch)
{
if (!(Math.Abs(prevDelta - currDelta) > deltaDifferenceEpsilon))
@@ -145,7 +147,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
// repeated island (ex: triplet -> triplet)
double power = logistic(island.AverageDelta(), 4, 0.165, 10);
- effectiveRatio *= Math.Min(2.0 / islandCounts[island], Math.Pow(1.0 / islandCounts[island], power));
+ effectiveRatio *= Math.Min(3.0 / islandCounts[island], Math.Pow(1.0 / islandCounts[island], power));
}
// scale down the difficulty if the object is doubletappable
diff --git a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
index 007cd977e5..a5ef0764bb 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/OsuDifficultyCalculator.cs
@@ -134,7 +134,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty
{
new Aim(mods, true),
new Aim(mods, false),
- new Speed(mods)
+ new Speed(mods, clockRate)
};
if (mods.Any(h => h is OsuModFlashlight))
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs b/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
index 40aac013ab..ae85980815 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Skills/Speed.cs
@@ -16,6 +16,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
///
public class Speed : OsuStrainSkill
{
+ private readonly double clockRate;
private double skillMultiplier => 1375;
private double strainDecayBase => 0.3;
@@ -27,9 +28,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
private readonly List objectStrains = new List();
- public Speed(Mod[] mods)
+ public Speed(Mod[] mods, double clockRate)
: base(mods)
{
+ this.clockRate = clockRate;
}
private double strainDecay(double ms) => Math.Pow(strainDecayBase, ms / 1000);
@@ -41,7 +43,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Skills
currentStrain *= strainDecay(((OsuDifficultyHitObject)current).StrainTime);
currentStrain += SpeedEvaluator.EvaluateDifficultyOf(current) * skillMultiplier;
- currentRhythm = RhythmEvaluator.EvaluateDifficultyOf(current);
+ currentRhythm = RhythmEvaluator.EvaluateDifficultyOf(current, clockRate);
double totalStrain = currentStrain * currentRhythm;
From 7fda8bc95b8092124820306cab26561e66cda8fe Mon Sep 17 00:00:00 2001
From: StanR
Date: Tue, 27 Aug 2024 23:48:15 +0500
Subject: [PATCH 155/924] Reduce repetition nerf for non-consecutive islands
---
.../Difficulty/Evaluators/RhythmEvaluator.cs | 37 +++++++++++--------
1 file changed, 22 insertions(+), 15 deletions(-)
diff --git a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
index 26f50efc72..9e851f11a6 100644
--- a/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
+++ b/osu.Game.Rulesets.Osu/Difficulty/Evaluators/RhythmEvaluator.cs
@@ -14,19 +14,24 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
{
private readonly struct Island : IEquatable
{
- public Island()
+ private readonly double deltaDifferenceEpsilon;
+
+ public Island(double epsilon)
{
+ deltaDifferenceEpsilon = epsilon;
}
public Island(int firstDelta, double epsilon)
{
- AddDelta(firstDelta, epsilon);
+ deltaDifferenceEpsilon = epsilon;
+ AddDelta(firstDelta);
}
public List Deltas { get; } = new List();
- public void AddDelta(int delta, double epsilon)
+ public void AddDelta(int delta)
{
+ double epsilon = deltaDifferenceEpsilon;
int existingDelta = Deltas.FirstOrDefault(x => Math.Abs(x - delta) >= epsilon);
Deltas.Add(existingDelta == default ? delta : existingDelta);
@@ -34,10 +39,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
public double AverageDelta() => Deltas.Count > 0 ? Math.Max(Deltas.Average(), OsuDifficultyHitObject.MIN_DELTA_TIME) : 0;
- public bool IsSimilarPolarity(Island other, double epsilon)
+ public bool IsSimilarPolarity(Island other)
{
// consider islands to be of similar polarity only if they're having the same average delta (we don't want to consider 3 singletaps similar to a triple)
- return Math.Abs(AverageDelta() - other.AverageDelta()) < epsilon &&
+ return Math.Abs(AverageDelta() - other.AverageDelta()) < deltaDifferenceEpsilon &&
Deltas.Count % 2 == other.Deltas.Count % 2;
}
@@ -61,7 +66,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
private const int history_time_max = 5 * 1000; // 5 seconds of calculatingRhythmBonus max.
private const int history_objects_max = 32;
- private const double rhythm_multiplier = 1.25;
+ private const double rhythm_multiplier = 1.2;
///
/// Calculates a rhythm multiplier for the difficulty of the tap associated with historic data of the current .
@@ -73,8 +78,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
double rhythmComplexitySum = 0;
- var island = new Island();
- var previousIsland = new Island();
+ double deltaDifferenceEpsilon = ((OsuDifficultyHitObject)current).HitWindowGreat * 0.3;
+
+ var island = new Island(deltaDifferenceEpsilon);
+ var previousIsland = new Island(deltaDifferenceEpsilon);
Dictionary islandCounts = new Dictionary();
int historyTimeMaxAdjusted = (int)Math.Ceiling(history_time_max / clockRate);
@@ -106,9 +113,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
double prevDelta = prevObj.StrainTime;
double lastDelta = lastObj.StrainTime;
- double currRatio = 1.0 + 7.27 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
-
- double deltaDifferenceEpsilon = currObj.HitWindowGreat * 0.3;
+ double currRatio = 1.0 + 5.8 * Math.Min(0.5, Math.Pow(Math.Sin(Math.PI / (Math.Min(prevDelta, currDelta) / Math.Max(prevDelta, currDelta))), 2)); // fancy function to calculate rhythmbonuses.
double windowPenalty = Math.Min(1, Math.Max(0, Math.Abs(prevDelta - currDelta) - deltaDifferenceEpsilon) / deltaDifferenceEpsilon);
@@ -119,7 +124,7 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
if (!(Math.Abs(prevDelta - currDelta) > deltaDifferenceEpsilon))
{
// island is still progressing
- island.AddDelta((int)currDelta, deltaDifferenceEpsilon);
+ island.AddDelta((int)currDelta);
}
else
{
@@ -131,10 +136,10 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
// unintentional side effect is that bursts with kicksliders at the ends might have lower difficulty than bursts without sliders
// therefore we're checking for quick sliders and don't lower the difficulty for them since they don't really make tapping easier (no time to adjust)
if (prevObj.BaseObject is Slider && prevObj.TravelTime > prevDelta * 1.5)
- effectiveRatio *= 0.15;
+ effectiveRatio *= 0.2;
// repeated island polartiy (2 -> 4, 3 -> 5)
- if (island.IsSimilarPolarity(previousIsland, deltaDifferenceEpsilon))
+ if (island.IsSimilarPolarity(previousIsland))
effectiveRatio *= 0.3;
// previous increase happened a note ago, 1/1->1/2-1/4, dont want to buff this.
@@ -143,7 +148,9 @@ namespace osu.Game.Rulesets.Osu.Difficulty.Evaluators
if (!islandCounts.TryAdd(island, 1))
{
- islandCounts[island]++;
+ // only add island to island counts if they're going one after another
+ if (previousIsland.Equals(island))
+ islandCounts[island]++;
// repeated island (ex: triplet -> triplet)
double power = logistic(island.AverageDelta(), 4, 0.165, 10);
From d4bfbe59174a7669d6027d704092ff829cb990d5 Mon Sep 17 00:00:00 2001
From: Dan Balasescu
Date: Thu, 29 Aug 2024 20:21:32 +0900
Subject: [PATCH 156/924] Add test
---
.../ManiaScoreProcessorTest.cs | 39 +++++++++++++++++++
1 file changed, 39 insertions(+)
create mode 100644 osu.Game.Rulesets.Mania.Tests/ManiaScoreProcessorTest.cs
diff --git a/osu.Game.Rulesets.Mania.Tests/ManiaScoreProcessorTest.cs b/osu.Game.Rulesets.Mania.Tests/ManiaScoreProcessorTest.cs
new file mode 100644
index 0000000000..1516aaf058
--- /dev/null
+++ b/osu.Game.Rulesets.Mania.Tests/ManiaScoreProcessorTest.cs
@@ -0,0 +1,39 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using NUnit.Framework;
+using osu.Game.Rulesets.Mania.Scoring;
+using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+ [TestFixture]
+ public class ManiaScoreProcessorTest
+ {
+ [TestCase(ScoreRank.X, 1, HitResult.Perfect)]
+ [TestCase(ScoreRank.X, 0.99, HitResult.Great)]
+ [TestCase(ScoreRank.D, 0.1, HitResult.Great)]
+ [TestCase(ScoreRank.X, 0.99, HitResult.Perfect, HitResult.Great)]
+ [TestCase(ScoreRank.X, 0.99, HitResult.Great, HitResult.Great)]
+ [TestCase(ScoreRank.S, 0.99, HitResult.Perfect, HitResult.Good)]
+ [TestCase(ScoreRank.S, 0.99, HitResult.Perfect, HitResult.Ok)]
+ [TestCase(ScoreRank.S, 0.99, HitResult.Perfect, HitResult.Meh)]
+ [TestCase(ScoreRank.S, 0.99, HitResult.Perfect, HitResult.Miss)]
+ [TestCase(ScoreRank.S, 0.99, HitResult.Great, HitResult.Good)]
+ [TestCase(ScoreRank.S, 0.99, HitResult.Great, HitResult.Ok)]
+ [TestCase(ScoreRank.S, 0.99, HitResult.Great, HitResult.Meh)]
+ [TestCase(ScoreRank.S, 0.99, HitResult.Great, HitResult.Miss)]
+ public void TestRanks(ScoreRank expected, double accuracy, params HitResult[] results)
+ {
+ var scoreProcessor = new ManiaScoreProcessor();
+
+ Dictionary resultsDict = new Dictionary();
+ foreach (var result in results)
+ resultsDict[result] = resultsDict.GetValueOrDefault(result) + 1;
+
+ Assert.That(scoreProcessor.RankFromScore(accuracy, resultsDict), Is.EqualTo(expected));
+ }
+ }
+}
From d59d5685d08ef99f15beba32e60f2ebe0c2b9c18 Mon Sep 17 00:00:00 2001
From: Dan Balasescu
Date: Thu, 29 Aug 2024 20:21:59 +0900
Subject: [PATCH 157/924] Make mania award SS even if there are GREAT
judgements
---
.../Scoring/ManiaScoreProcessor.cs | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs b/osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs
index 0444394d87..dfd6ed6dd2 100644
--- a/osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs
+++ b/osu.Game.Rulesets.Mania/Scoring/ManiaScoreProcessor.cs
@@ -9,6 +9,7 @@ using osu.Game.Rulesets.Judgements;
using osu.Game.Rulesets.Mania.Objects;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Scoring;
+using osu.Game.Scoring;
namespace osu.Game.Rulesets.Mania.Scoring
{
@@ -58,6 +59,24 @@ namespace osu.Game.Rulesets.Mania.Scoring
return GetBaseScoreForResult(result);
}
+ public override ScoreRank RankFromScore(double accuracy, IReadOnlyDictionary results)
+ {
+ ScoreRank rank = base.RankFromScore(accuracy, results);
+
+ if (rank != ScoreRank.S)
+ return rank;
+
+ // SS is expected as long as all hitobjects have been hit with either a GREAT or PERFECT result.
+
+ bool anyImperfect =
+ results.GetValueOrDefault(HitResult.Good) > 0
+ || results.GetValueOrDefault(HitResult.Ok) > 0
+ || results.GetValueOrDefault(HitResult.Meh) > 0
+ || results.GetValueOrDefault(HitResult.Miss) > 0;
+
+ return anyImperfect ? rank : ScoreRank.X;
+ }
+
private class JudgementOrderComparer : IComparer
{
public static readonly JudgementOrderComparer DEFAULT = new JudgementOrderComparer();
From d97a94aadd68aada70a8d808fdb7622e96267e44 Mon Sep 17 00:00:00 2001
From: Dan Balasescu
Date: Thu, 29 Aug 2024 20:22:54 +0900
Subject: [PATCH 158/924] Change accuracy circle to show badges based on score
rank
---
osu.Game/Screens/Ranking/Expanded/Accuracy/AccuracyCircle.cs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/osu.Game/Screens/Ranking/Expanded/Accuracy/AccuracyCircle.cs b/osu.Game/Screens/Ranking/Expanded/Accuracy/AccuracyCircle.cs
index cebc54f490..319a87fdfc 100644
--- a/osu.Game/Screens/Ranking/Expanded/Accuracy/AccuracyCircle.cs
+++ b/osu.Game/Screens/Ranking/Expanded/Accuracy/AccuracyCircle.cs
@@ -298,7 +298,7 @@ namespace osu.Game.Screens.Ranking.Expanded.Accuracy
{
foreach (var badge in badges)
{
- if (badge.Accuracy > score.Accuracy)
+ if (badge.Rank > score.Rank)
continue;
using (BeginDelayedSequence(
From ca2dc702e612986ccb40d7dcfe9fdb5acdb2d79b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?=
Date: Mon, 2 Sep 2024 09:52:00 +0200
Subject: [PATCH 159/924] Move helper class out to separate file
---
osu.Game/Screens/Edit/Timing/TimingSection.cs | 39 ----------------
.../Edit/Timing/TimingSectionAdjustments.cs | 46 +++++++++++++++++++
2 files changed, 46 insertions(+), 39 deletions(-)
create mode 100644 osu.Game/Screens/Edit/Timing/TimingSectionAdjustments.cs
diff --git a/osu.Game/Screens/Edit/Timing/TimingSection.cs b/osu.Game/Screens/Edit/Timing/TimingSection.cs
index 4b47ecaab6..139f53a961 100644
--- a/osu.Game/Screens/Edit/Timing/TimingSection.cs
+++ b/osu.Game/Screens/Edit/Timing/TimingSection.cs
@@ -1,17 +1,11 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
-using System.Collections.Generic;
-using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics;
-using osu.Framework.Utils;
-using osu.Game.Beatmaps;
using osu.Game.Beatmaps.ControlPoints;
using osu.Game.Graphics.UserInterfaceV2;
-using osu.Game.Rulesets.Objects;
-using osu.Game.Rulesets.Objects.Types;
namespace osu.Game.Screens.Edit.Timing
{
@@ -135,37 +129,4 @@ namespace osu.Game.Screens.Edit.Timing
private static double beatLengthToBpm(double beatLength) => 60000 / beatLength;
}
-
- public static class TimingSectionAdjustments
- {
- public static List HitObjectsInTimingRange(IBeatmap beatmap, double time)
- {
- // If the first group, we grab all hitobjects prior to the next, if the last group, we grab all remaining hitobjects
- double startTime = beatmap.ControlPointInfo.TimingPoints.Any(x => x.Time < time) ? time : double.MinValue;
- double endTime = beatmap.ControlPointInfo.TimingPoints.FirstOrDefault(x => x.Time > time)?.Time ?? double.MaxValue;
-
- return beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, startTime) && Precision.DefinitelyBigger(endTime, x.StartTime)).ToList();
- }
-
- public static void AdjustHitObjectOffset(IBeatmap beatmap, TimingControlPoint timingControlPoint, double adjust)
- {
- foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap, timingControlPoint.Time))
- {
- hitObject.StartTime += adjust;
- }
- }
-
- public static void SetHitObjectBPM(IBeatmap beatmap, TimingControlPoint timingControlPoint, double oldBeatLength)
- {
- foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap, timingControlPoint.Time))
- {
- double beat = (hitObject.StartTime - timingControlPoint.Time) / oldBeatLength;
-
- hitObject.StartTime = (beat * timingControlPoint.BeatLength) + timingControlPoint.Time;
-
- if (hitObject is not IHasRepeats && hitObject is IHasDuration hitObjectWithDuration)
- hitObjectWithDuration.Duration *= timingControlPoint.BeatLength / oldBeatLength;
- }
- }
- }
}
diff --git a/osu.Game/Screens/Edit/Timing/TimingSectionAdjustments.cs b/osu.Game/Screens/Edit/Timing/TimingSectionAdjustments.cs
new file mode 100644
index 0000000000..11c4be4790
--- /dev/null
+++ b/osu.Game/Screens/Edit/Timing/TimingSectionAdjustments.cs
@@ -0,0 +1,46 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Utils;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+
+namespace osu.Game.Screens.Edit.Timing
+{
+ public static class TimingSectionAdjustments
+ {
+ public static List HitObjectsInTimingRange(IBeatmap beatmap, double time)
+ {
+ // If the first group, we grab all hitobjects prior to the next, if the last group, we grab all remaining hitobjects
+ double startTime = beatmap.ControlPointInfo.TimingPoints.Any(x => x.Time < time) ? time : double.MinValue;
+ double endTime = beatmap.ControlPointInfo.TimingPoints.FirstOrDefault(x => x.Time > time)?.Time ?? double.MaxValue;
+
+ return beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, startTime) && Precision.DefinitelyBigger(endTime, x.StartTime)).ToList();
+ }
+
+ public static void AdjustHitObjectOffset(IBeatmap beatmap, TimingControlPoint timingControlPoint, double adjust)
+ {
+ foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap, timingControlPoint.Time))
+ {
+ hitObject.StartTime += adjust;
+ }
+ }
+
+ public static void SetHitObjectBPM(IBeatmap beatmap, TimingControlPoint timingControlPoint, double oldBeatLength)
+ {
+ foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap, timingControlPoint.Time))
+ {
+ double beat = (hitObject.StartTime - timingControlPoint.Time) / oldBeatLength;
+
+ hitObject.StartTime = (beat * timingControlPoint.BeatLength) + timingControlPoint.Time;
+
+ if (hitObject is not IHasRepeats && hitObject is IHasDuration hitObjectWithDuration)
+ hitObjectWithDuration.Duration *= timingControlPoint.BeatLength / oldBeatLength;
+ }
+ }
+ }
+}
From e61fd080c14602c489d3ef5b4937bc441b2bbc86 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?=
Date: Mon, 2 Sep 2024 09:59:19 +0200
Subject: [PATCH 160/924] Retouch & document helper methods
---
.../Editing/TimingSectionAdjustmentsTest.cs | 10 ++++++++
.../Edit/Timing/TimingSectionAdjustments.cs | 23 +++++++++++++------
2 files changed, 26 insertions(+), 7 deletions(-)
create mode 100644 osu.Game.Tests/Editing/TimingSectionAdjustmentsTest.cs
diff --git a/osu.Game.Tests/Editing/TimingSectionAdjustmentsTest.cs b/osu.Game.Tests/Editing/TimingSectionAdjustmentsTest.cs
new file mode 100644
index 0000000000..2cb9e72c1f
--- /dev/null
+++ b/osu.Game.Tests/Editing/TimingSectionAdjustmentsTest.cs
@@ -0,0 +1,10 @@
+// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Game.Tests.Editing
+{
+ public class TimingSectionAdjustmentsTest
+ {
+
+ }
+}
diff --git a/osu.Game/Screens/Edit/Timing/TimingSectionAdjustments.cs b/osu.Game/Screens/Edit/Timing/TimingSectionAdjustments.cs
index 11c4be4790..65edc47ff5 100644
--- a/osu.Game/Screens/Edit/Timing/TimingSectionAdjustments.cs
+++ b/osu.Game/Screens/Edit/Timing/TimingSectionAdjustments.cs
@@ -13,26 +13,35 @@ namespace osu.Game.Screens.Edit.Timing
{
public static class TimingSectionAdjustments
{
- public static List HitObjectsInTimingRange(IBeatmap beatmap, double time)
+ ///
+ /// Returns all objects from which are affected by the supplied .
+ ///
+ public static List HitObjectsInTimingRange(IBeatmap beatmap, TimingControlPoint timingControlPoint)
{
// If the first group, we grab all hitobjects prior to the next, if the last group, we grab all remaining hitobjects
- double startTime = beatmap.ControlPointInfo.TimingPoints.Any(x => x.Time < time) ? time : double.MinValue;
- double endTime = beatmap.ControlPointInfo.TimingPoints.FirstOrDefault(x => x.Time > time)?.Time ?? double.MaxValue;
+ double startTime = beatmap.ControlPointInfo.TimingPoints.Any(x => x.Time < timingControlPoint.Time) ? timingControlPoint.Time : double.MinValue;
+ double endTime = beatmap.ControlPointInfo.TimingPoints.FirstOrDefault(x => x.Time > timingControlPoint.Time)?.Time ?? double.MaxValue;
return beatmap.HitObjects.Where(x => Precision.AlmostBigger(x.StartTime, startTime) && Precision.DefinitelyBigger(endTime, x.StartTime)).ToList();
}
- public static void AdjustHitObjectOffset(IBeatmap beatmap, TimingControlPoint timingControlPoint, double adjust)
+ ///
+ /// Moves all relevant objects after 's offset has been changed by .
+ ///
+ public static void AdjustHitObjectOffset(IBeatmap beatmap, TimingControlPoint timingControlPoint, double adjustment)
{
- foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap, timingControlPoint.Time))
+ foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap, timingControlPoint))
{
- hitObject.StartTime += adjust;
+ hitObject.StartTime += adjustment;
}
}
+ ///
+ /// Ensures all relevant objects are still snapped to the same beats after 's beat length / BPM has been changed.
+ ///
public static void SetHitObjectBPM(IBeatmap beatmap, TimingControlPoint timingControlPoint, double oldBeatLength)
{
- foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap, timingControlPoint.Time))
+ foreach (HitObject hitObject in HitObjectsInTimingRange(beatmap, timingControlPoint))
{
double beat = (hitObject.StartTime - timingControlPoint.Time) / oldBeatLength;
From db608159cf6a6b1dcbcd56a668765d94a9593c77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?=
Date: Mon, 2 Sep 2024 10:27:40 +0200
Subject: [PATCH 161/924] Add test coverage
---
.../Editing/TimingSectionAdjustmentsTest.cs | 153 +++++++++++++++++-
1 file changed, 152 insertions(+), 1 deletion(-)
diff --git a/osu.Game.Tests/Editing/TimingSectionAdjustmentsTest.cs b/osu.Game.Tests/Editing/TimingSectionAdjustmentsTest.cs
index 2cb9e72c1f..5f5a1760ea 100644
--- a/osu.Game.Tests/Editing/TimingSectionAdjustmentsTest.cs
+++ b/osu.Game.Tests/Editing/TimingSectionAdjustmentsTest.cs
@@ -1,10 +1,161 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit.Timing;
+
namespace osu.Game.Tests.Editing
{
+ [TestFixture]
public class TimingSectionAdjustmentsTest
{
-
+ [Test]
+ public void TestOffsetAdjustment()
+ {
+ var controlPoints = new ControlPointInfo();
+
+ controlPoints.Add(100, new TimingControlPoint { BeatLength = 100 });
+ controlPoints.Add(50_000, new TimingControlPoint { BeatLength = 200 });
+ controlPoints.Add(100_000, new TimingControlPoint { BeatLength = 50 });
+
+ var beatmap = new Beatmap
+ {
+ ControlPointInfo = controlPoints,
+ HitObjects = new List
+ {
+ new HitCircle { StartTime = 0 },
+ new HitCircle { StartTime = 200 },
+ new HitCircle { StartTime = 49_900 },
+ new HitCircle { StartTime = 50_000 },
+ new HitCircle { StartTime = 50_200 },
+ new HitCircle { StartTime = 99_800 },
+ new HitCircle { StartTime = 100_000 },
+ new HitCircle { StartTime = 100_050 },
+ new HitCircle { StartTime = 100_550 },
+ }
+ };
+
+ moveTimingPoint(beatmap, 100, -50);
+
+ Assert.Multiple(() =>
+ {
+ Assert.That(beatmap.HitObjects[0].StartTime, Is.EqualTo(-50));
+ Assert.That(beatmap.HitObjects[1].StartTime, Is.EqualTo(150));
+ Assert.That(beatmap.HitObjects[2].StartTime, Is.EqualTo(49_850));
+ Assert.That(beatmap.HitObjects[3].StartTime, Is.EqualTo(50_000));
+ });
+
+ moveTimingPoint(beatmap, 50_000, 1_000);
+
+ Assert.Multiple(() =>
+ {
+ Assert.That(beatmap.HitObjects[2].StartTime, Is.EqualTo(49_850));
+ Assert.That(beatmap.HitObjects[3].StartTime, Is.EqualTo(51_000));
+ Assert.That(beatmap.HitObjects[4].StartTime, Is.EqualTo(51_200));
+ Assert.That(beatmap.HitObjects[5].StartTime, Is.EqualTo(100_800));
+ Assert.That(beatmap.HitObjects[6].StartTime, Is.EqualTo(100_000));
+ });
+
+ moveTimingPoint(beatmap, 100_000, 10_000);
+
+ Assert.Multiple(() =>
+ {
+ Assert.That(beatmap.HitObjects[4].StartTime, Is.EqualTo(51_200));
+ Assert.That(beatmap.HitObjects[5].StartTime, Is.EqualTo(110_800));
+ Assert.That(beatmap.HitObjects[6].StartTime, Is.EqualTo(110_000));
+ Assert.That(beatmap.HitObjects[7].StartTime, Is.EqualTo(110_050));
+ Assert.That(beatmap.HitObjects[8].StartTime, Is.EqualTo(110_550));
+ });
+ }
+
+ [Test]
+ public void TestBPMAdjustment()
+ {
+ var controlPoints = new ControlPointInfo();
+
+ controlPoints.Add(100, new TimingControlPoint { BeatLength = 100 });
+ controlPoints.Add(50_000, new TimingControlPoint { BeatLength = 200 });
+ controlPoints.Add(100_000, new TimingControlPoint { BeatLength = 50 });
+
+ var beatmap = new Beatmap
+ {
+ ControlPointInfo = controlPoints,
+ HitObjects = new List
+ {
+ new HitCircle { StartTime = 0 },
+ new HitCircle { StartTime = 200 },
+ new Spinner { StartTime = 500, EndTime = 1000 },
+ new HitCircle { StartTime = 49_900 },
+ new HitCircle { StartTime = 50_000 },
+ new HitCircle { StartTime = 50_200 },
+ new HitCircle { StartTime = 99_800 },
+ new HitCircle { StartTime = 100_000 },
+ new HitCircle { StartTime = 100_050 },
+ new HitCircle { StartTime = 100_550 },
+ }
+ };
+
+ adjustBeatLength(beatmap, 100, 50);
+
+ Assert.Multiple(() =>
+ {
+ Assert.That(beatmap.HitObjects[0].StartTime, Is.EqualTo(50));
+ Assert.That(beatmap.HitObjects[1].StartTime, Is.EqualTo(150));
+ Assert.That(beatmap.HitObjects[2].StartTime, Is.EqualTo(300));
+ Assert.That(beatmap.HitObjects[2].GetEndTime(), Is.EqualTo(550));
+ Assert.That(beatmap.HitObjects[3].StartTime, Is.EqualTo(25_000));
+ Assert.That(beatmap.HitObjects[4].StartTime, Is.EqualTo(50_000));
+ });
+
+ adjustBeatLength(beatmap, 50_000, 400);
+
+ Assert.Multiple(() =>
+ {
+ Assert.That(beatmap.HitObjects[2].StartTime, Is.EqualTo(300));
+ Assert.That(beatmap.HitObjects[2].GetEndTime(), Is.EqualTo(550));
+ Assert.That(beatmap.HitObjects[3].StartTime, Is.EqualTo(25_000));
+ Assert.That(beatmap.HitObjects[4].StartTime, Is.EqualTo(50_000));
+ Assert.That(beatmap.HitObjects[5].StartTime, Is.EqualTo(50_400));
+ Assert.That(beatmap.HitObjects[6].StartTime, Is.EqualTo(149_600));
+ Assert.That(beatmap.HitObjects[7].StartTime, Is.EqualTo(100_000));
+ });
+
+ adjustBeatLength(beatmap, 100_000, 100);
+
+ Assert.Multiple(() =>
+ {
+ Assert.That(beatmap.HitObjects[5].StartTime, Is.EqualTo(50_400));
+ Assert.That(beatmap.HitObjects[6].StartTime, Is.EqualTo(199_200));
+ Assert.That(beatmap.HitObjects[7].StartTime, Is.EqualTo(100_000));
+ Assert.That(beatmap.HitObjects[8].StartTime, Is.EqualTo(100_100));
+ Assert.That(beatmap.HitObjects[9].StartTime, Is.EqualTo(101_100));
+ });
+ }
+
+ private static void moveTimingPoint(IBeatmap beatmap, double originalTime, double adjustment)
+ {
+ var controlPoints = beatmap.ControlPointInfo;
+ var controlPointGroup = controlPoints.GroupAt(originalTime);
+ var timingPoint = controlPointGroup.ControlPoints.OfType().Single();
+ controlPoints.RemoveGroup(controlPointGroup);
+ TimingSectionAdjustments.AdjustHitObjectOffset(beatmap, timingPoint, adjustment);
+ controlPoints.Add(originalTime - adjustment, timingPoint);
+ }
+
+ private static void adjustBeatLength(IBeatmap beatmap, double groupTime, double newBeatLength)
+ {
+ var controlPoints = beatmap.ControlPointInfo;
+ var controlPointGroup = controlPoints.GroupAt(groupTime);
+ var timingPoint = controlPointGroup.ControlPoints.OfType().Single();
+ double oldBeatLength = timingPoint.BeatLength;
+ timingPoint.BeatLength = newBeatLength;
+ TimingSectionAdjustments.SetHitObjectBPM(beatmap, timingPoint, oldBeatLength);
+ }
}
}
From 3eaffbb70a0ca053fb3c3443b8a846d817968a70 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?=
Date: Mon, 2 Sep 2024 10:40:55 +0200
Subject: [PATCH 162/924] Make application of offset/BPM object adjustments
more sane
---
osu.Game/Screens/Edit/Timing/GroupSection.cs | 6 ++++--
.../Screens/Edit/Timing/TapTimingControl.cs | 17 ++++++++++++++---
osu.Game/Screens/Edit/Timing/TimingSection.cs | 2 ++
3 files changed, 20 insertions(+), 5 deletions(-)
diff --git a/osu.Game/Screens/Edit/Timing/GroupSection.cs b/osu.Game/Screens/Edit/Timing/GroupSection.cs
index 18a222f414..abcdf7e4ff 100644
--- a/osu.Game/Screens/Edit/Timing/GroupSection.cs
+++ b/osu.Game/Screens/Edit/Timing/GroupSection.cs
@@ -113,15 +113,17 @@ namespace osu.Game.Screens.Edit.Timing
{
// Only adjust hit object offsets if the group contains a timing control point
if (Beatmap.AdjustNotesOnOffsetBPMChange.Value && cp is TimingControlPoint tp)
+ {
TimingSectionAdjustments.AdjustHitObjectOffset(Beatmap, tp, time - SelectedGroup.Value.Time);
+ Beatmap.UpdateAllHitObjects();
+ }
+
Beatmap.ControlPointInfo.Add(time, cp);
}
// the control point might not necessarily exist yet, if currentGroupItems was empty.
SelectedGroup.Value = Beatmap.ControlPointInfo.GroupAt(time, true);
- Beatmap.UpdateAllHitObjects();
-
changeHandler?.EndChange();
}
}
diff --git a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
index f2e37369d1..91a0a43d62 100644
--- a/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
+++ b/osu.Game/Screens/Edit/Timing/TapTimingControl.cs
@@ -202,6 +202,7 @@ namespace osu.Game.Screens.Edit.Timing
// VERY TEMPORARY
var currentGroupItems = selectedGroup.Value.ControlPoints.ToArray();
+ beatmap.BeginChange();
beatmap.ControlPointInfo.RemoveGroup(selectedGroup.Value);
double newOffset = selectedGroup.Value.Time + adjust;
@@ -209,17 +210,20 @@ namespace osu.Game.Screens.Edit.Timing
foreach (var cp in currentGroupItems)
{
if (beatmap.AdjustNotesOnOffsetBPMChange.Value && cp is TimingControlPoint tp)
+ {
TimingSectionAdjustments.AdjustHitObjectOffset(beatmap, tp, adjust);
+ beatmap.UpdateAllHitObjects();
+ }
+
beatmap.ControlPointInfo.Add(newOffset, cp);
}
// the control point might not necessarily exist yet, if currentGroupItems was empty.
selectedGroup.Value = beatmap.ControlPointInfo.GroupAt(newOffset, true);
+ beatmap.EndChange();
if (!editorClock.IsRunning && wasAtStart)
editorClock.Seek(newOffset);
-
- beatmap.UpdateAllHitObjects();
}
private void adjustBpm(double adjust)
@@ -229,9 +233,16 @@ namespace osu.Game.Screens.Edit.Timing
if (timing == null)
return;
+ double oldBeatLength = timing.BeatLength;
timing.BeatLength = 60000 / (timing.BPM + adjust);
- beatmap.UpdateAllHitObjects();
+ if (beatmap.AdjustNotesOnOffsetBPMChange.Value)
+ {
+ beatmap.BeginChange();
+ TimingSectionAdjustments.SetHitObjectBPM(beatmap, timing, oldBeatLength);
+ beatmap.UpdateAllHitObjects();
+ beatmap.EndChange();
+ }
}
private partial class InlineButton : OsuButton
diff --git a/osu.Game/Screens/Edit/Timing/TimingSection.cs b/osu.Game/Screens/Edit/Timing/TimingSection.cs
index 139f53a961..e1567d65aa 100644
--- a/osu.Game/Screens/Edit/Timing/TimingSection.cs
+++ b/osu.Game/Screens/Edit/Timing/TimingSection.cs
@@ -48,8 +48,10 @@ namespace osu.Game.Screens.Edit.Timing
if (!Beatmap.AdjustNotesOnOffsetBPMChange.Value || ControlPoint.Value == null)
return;
+ Beatmap.BeginChange();
TimingSectionAdjustments.SetHitObjectBPM(Beatmap, ControlPoint.Value, val.OldValue);
Beatmap.UpdateAllHitObjects();
+ Beatmap.EndChange();
});
}
From 57f1259a336163aac5439e34c88f5c7a1d35b8ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?=
Date: Mon, 2 Sep 2024 10:49:31 +0200
Subject: [PATCH 163/924] Fix weirdness around spurious adjustments firing due
to overloaded bindable
---
osu.Game/Screens/Edit/Timing/TimingSection.cs | 14 ++++++++++----
1 file changed, 10 insertions(+), 4 deletions(-)
diff --git a/osu.Game/Screens/Edit/Timing/TimingSection.cs b/osu.Game/Screens/Edit/Timing/TimingSection.cs
index e1567d65aa..e668120d0d 100644
--- a/osu.Game/Screens/Edit/Timing/TimingSection.cs
+++ b/osu.Game/Screens/Edit/Timing/TimingSection.cs
@@ -1,6 +1,7 @@
// Copyright (c) ppy Pty Ltd . Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
+using System;
using osu.Framework.Allocation;
using osu.Framework.Bindables;
using osu.Framework.Graphics;
@@ -43,16 +44,16 @@ namespace osu.Game.Screens.Edit.Timing
if (!isRebinding) ChangeHandler?.SaveState();
}
- bpmTextEntry.Bindable.BindValueChanged(val =>
+ bpmTextEntry.OnCommit = (oldBeatLength, _) =>
{
if (!Beatmap.AdjustNotesOnOffsetBPMChange.Value || ControlPoint.Value == null)
return;
Beatmap.BeginChange();
- TimingSectionAdjustments.SetHitObjectBPM(Beatmap, ControlPoint.Value, val.OldValue);
+ TimingSectionAdjustments.SetHitObjectBPM(Beatmap, ControlPoint.Value, oldBeatLength);
Beatmap.UpdateAllHitObjects();
Beatmap.EndChange();
- });
+ };
}
private bool isRebinding;
@@ -85,6 +86,8 @@ namespace osu.Game.Screens.Edit.Timing
private partial class BPMTextBox : LabelledTextBox
{
+ public new Action? OnCommit { get; set; }
+
private readonly BindableNumber beatLengthBindable = new TimingControlPoint().BeatLengthBindable;
public BPMTextBox()
@@ -92,10 +95,12 @@ namespace osu.Game.Screens.Edit.Timing
Label = "BPM";
SelectAllOnFocus = true;
- OnCommit += (_, isNew) =>
+ base.OnCommit += (_, isNew) =>
{
if (!isNew) return;
+ double oldBeatLength = beatLengthBindable.Value;
+
try
{
if (double.TryParse(Current.Value, out double doubleVal) && doubleVal > 0)
@@ -109,6 +114,7 @@ namespace osu.Game.Screens.Edit.Timing
// This is run regardless of parsing success as the parsed number may not actually trigger a change
// due to bindable clamping. Even in such a case we want to update the textbox to a sane visual state.
beatLengthBindable.TriggerChange();
+ OnCommit?.Invoke(oldBeatLength, beatLengthBindable.Value);
};
beatLengthBindable.BindValueChanged(val =>
From 3531f646f232eb21ed14b27f31a43884e425d547 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Dach?=
Date: Thu, 18 Jul 2024 09:46:06 +0200
Subject: [PATCH 164/924] Refactor `DrawableOsuMenuItem` to remove a hack
---
.../UserInterface/DrawableOsuMenuItem.cs | 41 +++++++++++--------
.../UserInterface/DrawableStatefulMenuItem.cs | 10 +----
2 files changed, 25 insertions(+), 26 deletions(-)
diff --git a/osu.Game/Graphics/UserInterface/DrawableOsuMenuItem.cs b/osu.Game/Graphics/UserInterface/DrawableOsuMenuItem.cs
index 06ef75cf58..703dcbf3b7 100644
--- a/osu.Game/Graphics/UserInterface/DrawableOsuMenuItem.cs
+++ b/osu.Game/Graphics/UserInterface/DrawableOsuMenuItem.cs
@@ -124,7 +124,7 @@ namespace osu.Game.Graphics.UserInterface
protected sealed override Drawable CreateContent() => text = CreateTextContainer();
protected virtual TextContainer CreateTextContainer() => new TextContainer();
- protected partial class TextContainer : Container, IHasText
+ protected partial class TextContainer : FillFlowContainer, IHasText
{
public LocalisableString Text
{
@@ -145,25 +145,32 @@ namespace osu.Game.Graphics.UserInterface
Origin = Anchor.CentreLeft;
AutoSizeAxes = Axes.Both;
+ Spacing = new Vector2(10);
+ Direction = FillDirection.Horizontal;
- Children = new Drawable[]
+ Child = new Container
{
- NormalText = new OsuSpriteText
+ Anchor = Anchor.CentreLeft,
+ Origin = Anchor.CentreLeft,
+ AutoSizeAxes = Axes.Both,
+ Margin = new MarginPadding { Horizontal = MARGIN_HORIZONTAL, Vertical = MARGIN_VERTICAL },
+ Children = new Drawable[]
{
- AlwaysPresent = true, // ensures that the menu item does not change width when switching between normal and bold text.
- Anchor = Anchor.CentreLeft,
- Origin = Anchor.CentreLeft,
- Font = OsuFont.GetFont(size: text_size),
- Margin = new MarginPadding { Horizontal = MARGIN_HORIZONTAL, Vertical = MARGIN_VERTICAL },
- },
- BoldText = new OsuSpriteText
- {
- AlwaysPresent = true, // ensures that the menu item does not change width when switching between normal and bold text.
- Alpha = 0,
- Anchor = Anchor.CentreLeft,
- Origin = Anchor.CentreLeft,
- Font = OsuFont.GetFont(size: text_size, weight: FontWeight.Bold),
- Margin = new MarginPadding { Horizontal = MARGIN_HORIZONTAL, Vertical = MARGIN_VERTICAL },
+ NormalText = new OsuSpriteText
+ {
+ AlwaysPresent = true, // ensures that the menu item does not change width when switching between normal and bold text.
+ Anchor = Anchor.CentreLeft,
+ Origin = Anchor.CentreLeft,
+ Font = OsuFont.GetFont(size: text_size),
+ },
+ BoldText = new OsuSpriteText
+ {
+ AlwaysPresent = true, // ensures that the menu item does not change width when switching between normal and bold text.
+ Alpha = 0,
+ Anchor = Anchor.CentreLeft,
+ Origin = Anchor.CentreLeft,
+ Font = OsuFont.GetFont(size: text_size, weight: FontWeight.Bold),
+ }
}
};
}
diff --git a/osu.Game/Graphics/UserInterface/DrawableStatefulMenuItem.cs b/osu.Game/Graphics/UserInterface/DrawableStatefulMenuItem.cs
index b9e81e1bf2..6888c2c71b 100644
--- a/osu.Game/Graphics/UserInterface/DrawableStatefulMenuItem.cs
+++ b/osu.Game/Graphics/UserInterface/DrawableStatefulMenuItem.cs
@@ -51,7 +51,7 @@ namespace osu.Game.Graphics.UserInterface
Anchor = Anchor.CentreLeft,
Origin = Anchor.CentreLeft,
Size = new Vector2(10),
- Margin = new MarginPadding { Horizontal = MARGIN_HORIZONTAL },
+ Margin = new MarginPadding { Left = -MARGIN_HORIZONTAL, Right = MARGIN_HORIZONTAL },
AlwaysPresent = true,
});
}
@@ -62,14 +62,6 @@ namespace osu.Game.Graphics.UserInterface
state.BindValueChanged(updateState, true);
}
- protected override void Update()
- {
- base.Update();
-
- // Todo: This is bad. This can maybe be done better with a refactor of DrawableOsuMenuItem.
- stateIcon.X = BoldText.DrawWidth + 10;
- }
-
private void updateState(ValueChangedEvent