From 806d3160f8878b2283f4d817e6058a608fbf841f Mon Sep 17 00:00:00 2001 From: Hivie Date: Thu, 24 Jul 2025 13:12:24 +0100 Subject: [PATCH 1/4] Account for almost concurrent case in concurrent objects check --- .../Checks/CheckManiaConcurrentObjectsTest.cs | 18 +++++ .../Checks/CheckManiaConcurrentObjects.cs | 22 +++++-- .../Checks/CheckConcurrentObjectsTest.cs | 36 ++++++++++ .../Edit/Checks/CheckConcurrentObjects.cs | 65 +++++++++++++++++-- 4 files changed, 128 insertions(+), 13 deletions(-) diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs b/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs index 5af2af9314..0896f3bf1e 100644 --- a/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs +++ b/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs @@ -55,6 +55,16 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks }); } + [Test] + public void TestHoldNotesAlmostConcurrentOnSameColumn() + { + assertAlmostConcurrentSame(new List + { + createHoldNote(startTime: 100, endTime: 400.75d, column: 1), + createHoldNote(startTime: 408, endTime: 700.75d, column: 1) + }); + } + private void assertOk(List hitobjects) { Assert.That(check.Run(getContext(hitobjects)), Is.Empty); @@ -68,6 +78,14 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentSame)); } + private void assertAlmostConcurrentSame(List hitobjects) + { + var issues = check.Run(getContext(hitobjects)).ToList(); + + Assert.That(issues, Has.Count.EqualTo(1)); + Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrentSame)); + } + private BeatmapVerifierContext getContext(List hitobjects) { var beatmap = new Beatmap { HitObjects = hitobjects }; diff --git a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs index 569217207c..855c0bb792 100644 --- a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs +++ b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs @@ -28,14 +28,24 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks continue; // Two hitobjects cannot be concurrent without also being concurrent with all objects in between. - // So if the next object is not concurrent, then we know no future objects will be either. - if (!AreConcurrent(hitobject, nextHitobject)) + // So if the next object is not concurrent or almost concurrent, then we know no future objects will be either. + if (!AreConcurrent(hitobject, nextHitobject) && !AreAlmostConcurrent(hitobject, nextHitobject)) break; - if (hitobject.GetType() == nextHitobject.GetType()) - yield return new IssueTemplateConcurrentSame(this).Create(hitobject, nextHitobject); - else - yield return new IssueTemplateConcurrentDifferent(this).Create(hitobject, nextHitobject); + if (AreConcurrent(hitobject, nextHitobject)) + { + if (hitobject.GetType() == nextHitobject.GetType()) + yield return new IssueTemplateConcurrentSame(this).Create(hitobject, nextHitobject); + else + yield return new IssueTemplateConcurrentDifferent(this).Create(hitobject, nextHitobject); + } + else if (AreAlmostConcurrent(hitobject, nextHitobject)) + { + if (hitobject.GetType() == nextHitobject.GetType()) + yield return new IssueTemplateAlmostConcurrentSame(this).Create(hitobject, nextHitobject); + else + yield return new IssueTemplateAlmostConcurrentDifferent(this).Create(hitobject, nextHitobject); + } } } } diff --git a/osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs b/osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs index a255f41653..5a0618c9bf 100644 --- a/osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs +++ b/osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs @@ -57,6 +57,16 @@ namespace osu.Game.Tests.Editing.Checks }); } + [Test] + public void TestCirclesAlmostConcurrentWarning() + { + assertAlmostConcurrentSame(new List + { + new HitCircle { StartTime = 100 }, + new HitCircle { StartTime = 108 } + }); + } + [Test] public void TestSlidersSeparate() { @@ -97,6 +107,16 @@ namespace osu.Game.Tests.Editing.Checks }); } + [Test] + public void TestSliderAndCircleAlmostConcurrent() + { + assertAlmostConcurrentDifferent(new List + { + getSliderMock(startTime: 100, endTime: 400.75d).Object, + new HitCircle { StartTime = 408 } + }); + } + [Test] public void TestManyObjectsConcurrent() { @@ -155,6 +175,22 @@ namespace osu.Game.Tests.Editing.Checks Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentDifferent)); } + private void assertAlmostConcurrentSame(List hitobjects) + { + var issues = check.Run(getContext(hitobjects)).ToList(); + + Assert.That(issues, Has.Count.EqualTo(1)); + Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrentSame)); + } + + private void assertAlmostConcurrentDifferent(List hitobjects) + { + var issues = check.Run(getContext(hitobjects)).ToList(); + + Assert.That(issues, Has.Count.EqualTo(1)); + Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrentDifferent)); + } + private BeatmapVerifierContext getContext(List hitobjects) { var beatmap = new Beatmap { HitObjects = hitobjects }; diff --git a/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs b/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs index c0089e6fe2..586fb56e66 100644 --- a/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs +++ b/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs @@ -4,6 +4,7 @@ using System.Collections.Generic; using osu.Game.Rulesets.Edit.Checks.Components; using osu.Game.Rulesets.Objects; +using System; namespace osu.Game.Rulesets.Edit.Checks { @@ -11,13 +12,16 @@ namespace osu.Game.Rulesets.Edit.Checks { // We guarantee that the objects are either treated as concurrent or unsnapped when near the same beat divisor. private const double ms_leniency = CheckUnsnappedObjects.UNSNAP_MS_THRESHOLD; + private const double almost_concurrent_threshold = 10.0; public CheckMetadata Metadata { get; } = new CheckMetadata(CheckCategory.Compose, "Concurrent hitobjects"); public IEnumerable PossibleTemplates => new IssueTemplate[] { new IssueTemplateConcurrentSame(this), - new IssueTemplateConcurrentDifferent(this) + new IssueTemplateConcurrentDifferent(this), + new IssueTemplateAlmostConcurrentSame(this), + new IssueTemplateAlmostConcurrentDifferent(this) }; public virtual IEnumerable Run(BeatmapVerifierContext context) @@ -33,20 +37,33 @@ namespace osu.Game.Rulesets.Edit.Checks var nextHitobject = hitObjects[j]; // Two hitobjects cannot be concurrent without also being concurrent with all objects in between. - // So if the next object is not concurrent, then we know no future objects will be either. - if (!AreConcurrent(hitobject, nextHitobject)) + // So if the next object is not concurrent or almost concurrent, then we know no future objects will be either. + if (!AreConcurrent(hitobject, nextHitobject) && !AreAlmostConcurrent(hitobject, nextHitobject)) break; - if (hitobject.GetType() == nextHitobject.GetType()) - yield return new IssueTemplateConcurrentSame(this).Create(hitobject, nextHitobject); - else - yield return new IssueTemplateConcurrentDifferent(this).Create(hitobject, nextHitobject); + if (AreConcurrent(hitobject, nextHitobject)) + { + if (hitobject.GetType() == nextHitobject.GetType()) + yield return new IssueTemplateConcurrentSame(this).Create(hitobject, nextHitobject); + else + yield return new IssueTemplateConcurrentDifferent(this).Create(hitobject, nextHitobject); + } + else if (AreAlmostConcurrent(hitobject, nextHitobject)) + { + if (hitobject.GetType() == nextHitobject.GetType()) + yield return new IssueTemplateAlmostConcurrentSame(this).Create(hitobject, nextHitobject); + else + yield return new IssueTemplateAlmostConcurrentDifferent(this).Create(hitobject, nextHitobject); + } } } } protected bool AreConcurrent(HitObject hitobject, HitObject nextHitobject) => nextHitobject.StartTime <= hitobject.GetEndTime() + ms_leniency; + protected bool AreAlmostConcurrent(HitObject hitobject, HitObject nextHitobject) => + Math.Abs(nextHitobject.StartTime - hitobject.GetEndTime()) < almost_concurrent_threshold; + public abstract class IssueTemplateConcurrent : IssueTemplate { protected IssueTemplateConcurrent(ICheck check, string unformattedMessage) @@ -79,5 +96,39 @@ namespace osu.Game.Rulesets.Edit.Checks { } } + + public class IssueTemplateAlmostConcurrentSame : IssueTemplate + { + public IssueTemplateAlmostConcurrentSame(ICheck check) + : base(check, IssueType.Problem, "{0}s are less than 10ms apart.") + { + } + + public Issue Create(HitObject hitobject, HitObject nextHitobject) + { + var hitobjects = new List { hitobject, nextHitobject }; + return new Issue(hitobjects, this, hitobject.GetType().Name) + { + Time = nextHitobject.StartTime + }; + } + } + + public class IssueTemplateAlmostConcurrentDifferent : IssueTemplate + { + public IssueTemplateAlmostConcurrentDifferent(ICheck check) + : base(check, IssueType.Problem, "{0} and {1} are less than 10ms apart.") + { + } + + public Issue Create(HitObject hitobject, HitObject nextHitobject) + { + var hitobjects = new List { hitobject, nextHitobject }; + return new Issue(hitobjects, this, hitobject.GetType().Name, nextHitobject.GetType().Name) + { + Time = nextHitobject.StartTime + }; + } + } } } From c0ba8bc997165446a870be1b5219d67c4303b648 Mon Sep 17 00:00:00 2001 From: Hivie Date: Thu, 24 Jul 2025 13:25:15 +0100 Subject: [PATCH 2/4] refactor issue templates to be more unified --- .../Checks/CheckManiaConcurrentObjectsTest.cs | 6 +- .../Checks/CheckManiaConcurrentObjects.cs | 12 +-- .../Checks/CheckConcurrentObjectsTest.cs | 22 ++++-- .../Edit/Checks/CheckConcurrentObjects.cs | 77 ++++++------------- 4 files changed, 47 insertions(+), 70 deletions(-) diff --git a/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs b/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs index 0896f3bf1e..731263b25c 100644 --- a/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs +++ b/osu.Game.Rulesets.Mania.Tests/Editor/Checks/CheckManiaConcurrentObjectsTest.cs @@ -75,7 +75,8 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks var issues = check.Run(getContext(hitobjects)).ToList(); Assert.That(issues, Has.Count.EqualTo(count)); - Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentSame)); + Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrent)); + Assert.That(issues.All(issue => issue.ToString().Contains("s are concurrent here"))); } private void assertAlmostConcurrentSame(List hitobjects) @@ -83,7 +84,8 @@ namespace osu.Game.Rulesets.Mania.Tests.Editor.Checks var issues = check.Run(getContext(hitobjects)).ToList(); Assert.That(issues, Has.Count.EqualTo(1)); - Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrentSame)); + Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrent)); + Assert.That(issues.All(issue => issue.ToString().Contains("s are less than 10ms apart"))); } private BeatmapVerifierContext getContext(List hitobjects) diff --git a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs index 855c0bb792..c87ad7ba83 100644 --- a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs +++ b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs @@ -32,19 +32,15 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks if (!AreConcurrent(hitobject, nextHitobject) && !AreAlmostConcurrent(hitobject, nextHitobject)) break; + bool sameType = hitobject.GetType() == nextHitobject.GetType(); + if (AreConcurrent(hitobject, nextHitobject)) { - if (hitobject.GetType() == nextHitobject.GetType()) - yield return new IssueTemplateConcurrentSame(this).Create(hitobject, nextHitobject); - else - yield return new IssueTemplateConcurrentDifferent(this).Create(hitobject, nextHitobject); + yield return new IssueTemplateConcurrent(this).Create(hitobject, nextHitobject, sameType); } else if (AreAlmostConcurrent(hitobject, nextHitobject)) { - if (hitobject.GetType() == nextHitobject.GetType()) - yield return new IssueTemplateAlmostConcurrentSame(this).Create(hitobject, nextHitobject); - else - yield return new IssueTemplateAlmostConcurrentDifferent(this).Create(hitobject, nextHitobject); + yield return new IssueTemplateAlmostConcurrent(this).Create(hitobject, nextHitobject, sameType); } } } diff --git a/osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs b/osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs index 5a0618c9bf..fd63e1b05d 100644 --- a/osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs +++ b/osu.Game.Tests/Editing/Checks/CheckConcurrentObjectsTest.cs @@ -130,8 +130,14 @@ namespace osu.Game.Tests.Editing.Checks var issues = check.Run(getContext(hitobjects)).ToList(); Assert.That(issues, Has.Count.EqualTo(3)); - Assert.That(issues.Where(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentDifferent).ToList(), Has.Count.EqualTo(2)); - Assert.That(issues.Any(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentSame)); + Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrent)); + + // Should have 1 same-type concurrent (Slider & Slider) and 2 different-type concurrent (Slider & Circle) + var sameTypeIssues = issues.Where(issue => issue.ToString().Contains("s are concurrent here")).ToList(); + var differentTypeIssues = issues.Where(issue => issue.ToString().Contains(" and ") && issue.ToString().Contains("are concurrent here")).ToList(); + + Assert.That(sameTypeIssues, Has.Count.EqualTo(1)); + Assert.That(differentTypeIssues, Has.Count.EqualTo(2)); } private Mock getSliderMock(double startTime, double endTime, int repeats = 0) @@ -164,7 +170,8 @@ namespace osu.Game.Tests.Editing.Checks var issues = check.Run(getContext(hitobjects)).ToList(); Assert.That(issues, Has.Count.EqualTo(count)); - Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentSame)); + Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrent)); + Assert.That(issues.All(issue => issue.ToString().Contains("s are concurrent here"))); } private void assertConcurrentDifferent(List hitobjects, int count = 1) @@ -172,7 +179,8 @@ namespace osu.Game.Tests.Editing.Checks var issues = check.Run(getContext(hitobjects)).ToList(); Assert.That(issues, Has.Count.EqualTo(count)); - Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrentDifferent)); + Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateConcurrent)); + Assert.That(issues.All(issue => issue.ToString().Contains(" and ") && issue.ToString().Contains("are concurrent here"))); } private void assertAlmostConcurrentSame(List hitobjects) @@ -180,7 +188,8 @@ namespace osu.Game.Tests.Editing.Checks var issues = check.Run(getContext(hitobjects)).ToList(); Assert.That(issues, Has.Count.EqualTo(1)); - Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrentSame)); + Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrent)); + Assert.That(issues.All(issue => issue.ToString().Contains("s are less than 10ms apart"))); } private void assertAlmostConcurrentDifferent(List hitobjects) @@ -188,7 +197,8 @@ namespace osu.Game.Tests.Editing.Checks var issues = check.Run(getContext(hitobjects)).ToList(); Assert.That(issues, Has.Count.EqualTo(1)); - Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrentDifferent)); + Assert.That(issues.All(issue => issue.Template is CheckConcurrentObjects.IssueTemplateAlmostConcurrent)); + Assert.That(issues.All(issue => issue.ToString().Contains(" and ") && issue.ToString().Contains("are less than 10ms apart"))); } private BeatmapVerifierContext getContext(List hitobjects) diff --git a/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs b/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs index 586fb56e66..4839c93f9b 100644 --- a/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs +++ b/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs @@ -18,10 +18,8 @@ namespace osu.Game.Rulesets.Edit.Checks public IEnumerable PossibleTemplates => new IssueTemplate[] { - new IssueTemplateConcurrentSame(this), - new IssueTemplateConcurrentDifferent(this), - new IssueTemplateAlmostConcurrentSame(this), - new IssueTemplateAlmostConcurrentDifferent(this) + new IssueTemplateConcurrent(this), + new IssueTemplateAlmostConcurrent(this) }; public virtual IEnumerable Run(BeatmapVerifierContext context) @@ -41,19 +39,15 @@ namespace osu.Game.Rulesets.Edit.Checks if (!AreConcurrent(hitobject, nextHitobject) && !AreAlmostConcurrent(hitobject, nextHitobject)) break; + bool sameType = hitobject.GetType() == nextHitobject.GetType(); + if (AreConcurrent(hitobject, nextHitobject)) { - if (hitobject.GetType() == nextHitobject.GetType()) - yield return new IssueTemplateConcurrentSame(this).Create(hitobject, nextHitobject); - else - yield return new IssueTemplateConcurrentDifferent(this).Create(hitobject, nextHitobject); + yield return new IssueTemplateConcurrent(this).Create(hitobject, nextHitobject, sameType); } else if (AreAlmostConcurrent(hitobject, nextHitobject)) { - if (hitobject.GetType() == nextHitobject.GetType()) - yield return new IssueTemplateAlmostConcurrentSame(this).Create(hitobject, nextHitobject); - else - yield return new IssueTemplateAlmostConcurrentDifferent(this).Create(hitobject, nextHitobject); + yield return new IssueTemplateAlmostConcurrent(this).Create(hitobject, nextHitobject, sameType); } } } @@ -64,67 +58,42 @@ namespace osu.Game.Rulesets.Edit.Checks protected bool AreAlmostConcurrent(HitObject hitobject, HitObject nextHitobject) => Math.Abs(nextHitobject.StartTime - hitobject.GetEndTime()) < almost_concurrent_threshold; - public abstract class IssueTemplateConcurrent : IssueTemplate + public class IssueTemplateConcurrent : IssueTemplate { - protected IssueTemplateConcurrent(ICheck check, string unformattedMessage) - : base(check, IssueType.Problem, unformattedMessage) + public IssueTemplateConcurrent(ICheck check) + : base(check, IssueType.Problem, "{0}") { } - public Issue Create(HitObject hitobject, HitObject nextHitobject) + public Issue Create(HitObject hitobject, HitObject nextHitobject, bool sameType) { var hitobjects = new List { hitobject, nextHitobject }; - return new Issue(hitobjects, this, hitobject.GetType().Name, nextHitobject.GetType().Name) + string message = sameType + ? $"{hitobject.GetType().Name}s are concurrent here." + : $"{hitobject.GetType().Name} and {nextHitobject.GetType().Name} are concurrent here."; + + return new Issue(hitobjects, this, message) { Time = nextHitobject.StartTime }; } } - public class IssueTemplateConcurrentSame : IssueTemplateConcurrent + public class IssueTemplateAlmostConcurrent : IssueTemplate { - public IssueTemplateConcurrentSame(ICheck check) - : base(check, "{0}s are concurrent here.") - { - } - } - - public class IssueTemplateConcurrentDifferent : IssueTemplateConcurrent - { - public IssueTemplateConcurrentDifferent(ICheck check) - : base(check, "{0} and {1} are concurrent here.") - { - } - } - - public class IssueTemplateAlmostConcurrentSame : IssueTemplate - { - public IssueTemplateAlmostConcurrentSame(ICheck check) - : base(check, IssueType.Problem, "{0}s are less than 10ms apart.") + public IssueTemplateAlmostConcurrent(ICheck check) + : base(check, IssueType.Problem, "{0}") { } - public Issue Create(HitObject hitobject, HitObject nextHitobject) + public Issue Create(HitObject hitobject, HitObject nextHitobject, bool sameType) { var hitobjects = new List { hitobject, nextHitobject }; - return new Issue(hitobjects, this, hitobject.GetType().Name) - { - Time = nextHitobject.StartTime - }; - } - } + string message = sameType + ? $"{hitobject.GetType().Name}s are less than 10ms apart." + : $"{hitobject.GetType().Name} and {nextHitobject.GetType().Name} are less than 10ms apart."; - public class IssueTemplateAlmostConcurrentDifferent : IssueTemplate - { - public IssueTemplateAlmostConcurrentDifferent(ICheck check) - : base(check, IssueType.Problem, "{0} and {1} are less than 10ms apart.") - { - } - - public Issue Create(HitObject hitobject, HitObject nextHitobject) - { - var hitobjects = new List { hitobject, nextHitobject }; - return new Issue(hitobjects, this, hitobject.GetType().Name, nextHitobject.GetType().Name) + return new Issue(hitobjects, this, message) { Time = nextHitobject.StartTime }; From 8466d64c69c69709105c06a40e623161bc3c1298 Mon Sep 17 00:00:00 2001 From: Hivie Date: Mon, 28 Jul 2025 12:24:24 +0100 Subject: [PATCH 3/4] apply review --- .../Edit/Checks/CheckManiaConcurrentObjects.cs | 4 ++-- .../Edit/Checks/CheckConcurrentObjects.cs | 18 ++++++++---------- 2 files changed, 10 insertions(+), 12 deletions(-) diff --git a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs index c87ad7ba83..1dd9ec01b5 100644 --- a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs +++ b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs @@ -36,11 +36,11 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks if (AreConcurrent(hitobject, nextHitobject)) { - yield return new IssueTemplateConcurrent(this).Create(hitobject, nextHitobject, sameType); + yield return new IssueTemplateConcurrent(this).Create(hitobject, nextHitobject); } else if (AreAlmostConcurrent(hitobject, nextHitobject)) { - yield return new IssueTemplateAlmostConcurrent(this).Create(hitobject, nextHitobject, sameType); + yield return new IssueTemplateAlmostConcurrent(this).Create(hitobject, nextHitobject); } } } diff --git a/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs b/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs index 4839c93f9b..c23a944ffb 100644 --- a/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs +++ b/osu.Game/Rulesets/Edit/Checks/CheckConcurrentObjects.cs @@ -39,15 +39,13 @@ namespace osu.Game.Rulesets.Edit.Checks if (!AreConcurrent(hitobject, nextHitobject) && !AreAlmostConcurrent(hitobject, nextHitobject)) break; - bool sameType = hitobject.GetType() == nextHitobject.GetType(); - if (AreConcurrent(hitobject, nextHitobject)) { - yield return new IssueTemplateConcurrent(this).Create(hitobject, nextHitobject, sameType); + yield return new IssueTemplateConcurrent(this).Create(hitobject, nextHitobject); } else if (AreAlmostConcurrent(hitobject, nextHitobject)) { - yield return new IssueTemplateAlmostConcurrent(this).Create(hitobject, nextHitobject, sameType); + yield return new IssueTemplateAlmostConcurrent(this).Create(hitobject, nextHitobject); } } } @@ -65,10 +63,10 @@ namespace osu.Game.Rulesets.Edit.Checks { } - public Issue Create(HitObject hitobject, HitObject nextHitobject, bool sameType) + public Issue Create(HitObject hitobject, HitObject nextHitobject) { var hitobjects = new List { hitobject, nextHitobject }; - string message = sameType + string message = hitobject.GetType() == nextHitobject.GetType() ? $"{hitobject.GetType().Name}s are concurrent here." : $"{hitobject.GetType().Name} and {nextHitobject.GetType().Name} are concurrent here."; @@ -86,12 +84,12 @@ namespace osu.Game.Rulesets.Edit.Checks { } - public Issue Create(HitObject hitobject, HitObject nextHitobject, bool sameType) + public Issue Create(HitObject hitobject, HitObject nextHitobject) { var hitobjects = new List { hitobject, nextHitobject }; - string message = sameType - ? $"{hitobject.GetType().Name}s are less than 10ms apart." - : $"{hitobject.GetType().Name} and {nextHitobject.GetType().Name} are less than 10ms apart."; + string message = hitobject.GetType() == nextHitobject.GetType() + ? $"{hitobject.GetType().Name}s are less than {almost_concurrent_threshold}ms apart." + : $"{hitobject.GetType().Name} and {nextHitobject.GetType().Name} are less than {almost_concurrent_threshold}ms apart."; return new Issue(hitobjects, this, message) { From d5b0c5404c64e73f454231034a395d546b38be33 Mon Sep 17 00:00:00 2001 From: Hivie Date: Mon, 28 Jul 2025 12:38:16 +0100 Subject: [PATCH 4/4] remove unused var --- .../Edit/Checks/CheckManiaConcurrentObjects.cs | 2 -- 1 file changed, 2 deletions(-) diff --git a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs index 1dd9ec01b5..5c73a6b676 100644 --- a/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs +++ b/osu.Game.Rulesets.Mania/Edit/Checks/CheckManiaConcurrentObjects.cs @@ -32,8 +32,6 @@ namespace osu.Game.Rulesets.Mania.Edit.Checks if (!AreConcurrent(hitobject, nextHitobject) && !AreAlmostConcurrent(hitobject, nextHitobject)) break; - bool sameType = hitobject.GetType() == nextHitobject.GetType(); - if (AreConcurrent(hitobject, nextHitobject)) { yield return new IssueTemplateConcurrent(this).Create(hitobject, nextHitobject);