public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
foreach (var catchObject in catchObjects)
{
if (catchObject.Target == null)
{
continue;
}
if (catchObject.MovementType == MovementType.HYPERDASH)
{
if (catchObject.NoteType == NoteType.DROPLET || catchObject.NoteType == NoteType.REPEAT)
{
yield return(new Issue(
GetTemplate("SliderHyperPlatter"),
beatmap,
TimestampHelper.Get(catchObject, catchObject.Target),
catchObject.GetNoteTypeName()
).ForDifficulties(Beatmap.Difficulty.Hard));
yield return(new Issue(
GetTemplate("SliderHyperRain"),
beatmap,
TimestampHelper.Get(catchObject, catchObject.Target),
catchObject.GetNoteTypeName()
).ForDifficulties(Beatmap.Difficulty.Insane));
}
}
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
// All objects with potential issues
var issueObjects = new List <CatchHitObject>();
foreach (var catchObject in catchObjects)
{
if (catchObject.MovementType == MovementType.DASH)
{
issueObjects.Add(catchObject);
}
}
foreach (var issueObject in issueObjects.Where(issueObject => issueObject.IsEdgeMovement))
{
yield return(EdgeDashIssue(GetTemplate("EdgeDash"), beatmap, issueObject,
Beatmap.Difficulty.Insane));
yield return(EdgeDashIssue(GetTemplate("EdgeDashMinor"), beatmap, issueObject,
Beatmap.Difficulty.Expert, Beatmap.Difficulty.Ultra));
yield return(EdgeDashIssue(GetTemplate("EdgeDashProblem"), beatmap, issueObject,
Beatmap.Difficulty.Normal, Beatmap.Difficulty.Hard));
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
var issueObjects = new List <CatchHitObject>();
foreach (var currentObject in catchObjects
.Where(currentObject => currentObject.type != HitObject.Type.Spinner && currentObject.MovementType != MovementType.DASH))
{
var dashDistance = currentObject.DistanceToDash;
if (dashDistance > 0)
{
issueObjects.Add(currentObject);
}
}
foreach (var issueObject in issueObjects)
{
if (issueObject.DistanceToDash < 20)
{
yield return(EdgeWalkIssue(GetTemplate("EdgeWalk"), beatmap, issueObject,
Beatmap.Difficulty.Easy, Beatmap.Difficulty.Normal, Beatmap.Difficulty.Hard));
}
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
foreach (var dashObject in catchObjects.Where(catchObject => catchObject.MovementType == MovementType.DASH))
{
if (dashObject.Target == null)
{
continue;
}
// only higher-snapped objects need to be going to the same direction so we can basic-dashes.
if (!dashObject.IsHigherSnapped(Beatmap.Difficulty.Normal))
{
continue;
}
if (dashObject.Target.NoteDirection != dashObject.NoteDirection && Math.Abs(dashObject.Target.X - dashObject.X) > 20)
{
yield return(new Issue(
GetTemplate("Warning"),
beatmap,
TimestampHelper.Get(dashObject, dashObject.Target)
).ForDifficulties(Beatmap.Difficulty.Normal));
}
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
foreach (var catchObject in catchObjects.Where(catchObject =>
catchObject.MovementType == MovementType.HYPERDASH))
{
yield return(new Issue(
GetTemplate("Hyperdash"),
beatmap,
TimestampHelper.Get(catchObject, catchObject.Target),
catchObject.GetNoteTypeName()
).ForDifficulties(Beatmap.Difficulty.Easy, Beatmap.Difficulty.Normal));
switch (catchObject.NoteType)
{
case NoteType.HEAD:
case NoteType.REPEAT:
case NoteType.DROPLET:
yield return(new Issue(
GetTemplate("HyperdashSliderPart"),
beatmap,
TimestampHelper.Get(catchObject, catchObject.Target),
catchObject.GetNoteTypeName()
).ForDifficulties(Beatmap.Difficulty.Hard));
break;
}
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
if (catchObjects.Count == 0)
{
yield break;
}
CatchHitObject lastObject = null;
var nextMustBeWalkable = false;
var dashObjects = new List <CatchHitObject>();
foreach (var catchObject in catchObjects)
{
if (nextMustBeWalkable)
{
if (catchObject.MovementType != MovementType.WALK)
{
yield return(new Issue(
GetTemplate("HigherSnappedDash"),
beatmap,
TimestampHelper.Get(lastObject)
).ForDifficulties(Beatmap.Difficulty.Normal));
}
nextMustBeWalkable = false;
}
if (catchObject.MovementType == MovementType.DASH)
{
var isHigherSnapped = catchObject.IsHigherSnapped(Beatmap.Difficulty.Normal);
if (isHigherSnapped)
{
nextMustBeWalkable = true;
}
dashObjects.Add(catchObject);
}
else
{
if (dashObjects.Count > AllowedBasicSnappedDashes)
{
yield return(new Issue(
GetTemplate("AmountOfDashes"),
beatmap,
TimestampHelper.Get(dashObjects.ToArray()),
dashObjects.Count
).ForDifficulties(Beatmap.Difficulty.Normal));
}
// This was no dash so we can reset the counter
dashObjects = new List <CatchHitObject>();
}
lastObject = catchObject;
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
var consecutiveObjects = new List <CatchHitObject>();
var checkForIssues = false;
foreach (var currentObject in catchObjects)
{
if (currentObject.MovementType == MovementType.DASH)
{
if (!currentObject.IsHigherSnapped(Beatmap.Difficulty.Hard))
{
consecutiveObjects.Add(currentObject);
}
else
{
checkForIssues = true;
}
}
else
{
checkForIssues = true;
}
if (checkForIssues)
{
var total = consecutiveObjects.Count;
consecutiveObjects.Add(currentObject);
if (total > 2)
{
yield return(new Issue(
GetTemplate("BasicSnappedConsecutive"),
beatmap,
TimestampHelper.Get(consecutiveObjects.ToArray()),
2,
total
).ForDifficulties(Beatmap.Difficulty.Hard));
}
// Reset all values after checking for potential issues
consecutiveObjects = new List <CatchHitObject>();
checkForIssues = false;
}
}
var lastTotal = consecutiveObjects.Count;
if (lastTotal > 2)
{
yield return(new Issue(
GetTemplate("BasicSnappedConsecutive"),
beatmap,
TimestampHelper.Get(consecutiveObjects.ToArray()),
2,
lastTotal
).ForDifficulties(Beatmap.Difficulty.Hard));
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
foreach (var currentObject in catchObjects)
{
if (currentObject.Target == null)
{
continue;
}
if (currentObject.MovementType == MovementType.HYPERDASH)
{
var hyperTriggerDistance = (int)currentObject.GetTriggerDistance();
var currentTriggerDistance = (int)currentObject.GetCurrentTriggerDistance();
if (!currentObject.IsHigherSnapped(Beatmap.Difficulty.Hard))
{
// Check if next is antiflow
if (currentObject.NoteDirection != currentObject.Target.NoteDirection)
{
switch (currentObject.Target.MovementType)
{
case MovementType.WALK:
// When next is a walk it should not exceed 1.2
if (hyperTriggerDistance * 1.2 < currentTriggerDistance)
{
yield return(new Issue(
GetTemplate("AntiFlowWalk"),
beatmap,
TimestampHelper.Get(currentObject, currentObject.Target),
(int)(hyperTriggerDistance * 1.2)
).ForDifficulties(Beatmap.Difficulty.Hard));
}
break;
case MovementType.DASH:
// Otherwise only 1.1 if followed by a basic-snapped dash
if (!currentObject.Target.IsHigherSnapped(Beatmap.Difficulty.Hard) && hyperTriggerDistance * 1.1 < currentTriggerDistance)
{
yield return(new Issue(
GetTemplate("AntiFlowDash"),
beatmap,
TimestampHelper.Get(currentObject, currentObject.Target),
(int)(hyperTriggerDistance * 1.1)
).ForDifficulties(Beatmap.Difficulty.Hard));
}
// TODO
break;
}
}
}
}
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
foreach (var currentObject in catchObjects)
{
if (currentObject.Target == null)
{
continue;
}
if (currentObject.MovementType == MovementType.HYPERDASH)
{
var hyperTriggerDistance = (int)currentObject.GetTriggerDistance();
var currentTriggerDistance = (int)currentObject.GetCurrentTriggerDistance();
if (currentObject.IsHigherSnapped(Beatmap.Difficulty.Hard))
{
var isNextAWalk = currentObject.Target.MovementType == MovementType.WALK;
if (isNextAWalk)
{
// Hyperdashes that are higher-snapped should not be followed by antiflow patterns.
// If used, the spacing should not exceed a distance snap of 1.1 times the trigger distance
if (hyperTriggerDistance * 1.1 < currentTriggerDistance && currentObject.NoteDirection != currentObject.Target.NoteDirection)
{
yield return(new Issue(
GetTemplate("TooStrongHigherSnapFollowedByAntiFlow"),
beatmap,
TimestampHelper.Get(currentObject, currentObject.Target),
(int)(hyperTriggerDistance * 1.1)
).ForDifficulties(Beatmap.Difficulty.Hard));
}
}
else
{
// Hyperdashes that are higher-snapped must not be used in conjunction with any other dashes or hyperdashes.
yield return(new Issue(
GetTemplate("HigherSnapFollowedByDashesOrHyperdashes"),
beatmap,
TimestampHelper.Get(currentObject, currentObject.Target)
).ForDifficulties(Beatmap.Difficulty.Hard));
}
}
}
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
if (catchObjects.Count == 0)
{
yield break;
}
var nextShouldBeSameSnap = false;
CatchHitObject lastObject = null;
foreach (var catchObject in catchObjects)
{
if (nextShouldBeSameSnap)
{
if (catchObject.MovementType == MovementType.DASH &&
catchObject.IsHigherSnapped(Beatmap.Difficulty.Normal))
{
if (!lastObject.IsSameSnap(catchObject))
{
yield return(new Issue(
GetTemplate("Warning"),
beatmap,
TimestampHelper.Get(lastObject, catchObject, catchObject.Target)
).ForDifficulties(Beatmap.Difficulty.Normal));
}
}
nextShouldBeSameSnap = false;
}
if (catchObject.MovementType == MovementType.DASH)
{
var higherSnapped = catchObject.IsHigherSnapped(Beatmap.Difficulty.Normal);
if (higherSnapped)
{
continue;
}
nextShouldBeSameSnap = true;
lastObject = catchObject;
}
}
}
// TODO REWORK
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
if (catchObjects.Count == 0)
{
yield break;
}
var lastCheckedObject = catchObjects[0];
// We set i = 1 to skip the first object
for (var i = 1; i < catchObjects.Count; i++)
{
var currentObject = catchObjects[i];
if (lastCheckedObject.MovementType == MovementType.HYPERDASH)
{
var snap = (int)(currentObject.time - lastCheckedObject.time);
if (snap < 125 && snap > 0)
{
yield return(new Issue(
GetTemplate("HyperdashSnap"),
beatmap,
Timestamp.Get(currentObject.time),
125,
snap
).ForDifficulties(Beatmap.Difficulty.Hard));
}
if (snap < 62 && snap > 0)
{
yield return(new Issue(
GetTemplate("HyperdashSnap"),
beatmap,
Timestamp.Get(currentObject.time),
62,
snap
).ForDifficulties(Beatmap.Difficulty.Insane));
}
}
lastCheckedObject = currentObject;
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
foreach (var catchObject in catchObjects)
{
if (catchObject.MovementType == MovementType.DASH)
{
yield return(new Issue(
GetTemplate("Dash"),
beatmap,
TimestampHelper.Get(catchObject, catchObject.Target),
catchObject.GetNoteTypeName(),
catchObject.Target.GetNoteTypeName()
).ForDifficulties(Beatmap.Difficulty.Easy));
}
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
var hyperdashObjects = new List <CatchHitObject>();
foreach (var currentObject in catchObjects)
{
if (currentObject.MovementType == MovementType.HYPERDASH)
{
// Always count the amount of hypers.
hyperdashObjects.Add(currentObject);
}
else
{
foreach (var issue in GetConsecutiveHyperdashIssues(beatmap, hyperdashObjects.Count, hyperdashObjects.ToArray()))
{
yield return(issue);
}
hyperdashObjects = new List <CatchHitObject>();
}
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
foreach (var catchObject in catchObjects)
{
if (catchObject.Target == null)
{
continue;
}
if (catchObject.MovementType == MovementType.HYPERDASH && catchObject.Target.MovementType == MovementType.HYPERDASH)
{
if (!catchObject.IsSameSnap(catchObject.Target))
{
yield return(new Issue(
GetTemplate("DifferentSnapHyperdashes"),
beatmap,
TimestampHelper.Get(catchObject, catchObject.Target)
).ForDifficulties(Beatmap.Difficulty.Hard));
}
}
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
CatchHitObject basicSnappedHyperdash = null;
var sliderObjects = new List <CatchHitObject>();
foreach (var currentObject in catchObjects)
{
if (currentObject.Target == null)
{
continue;
}
if (basicSnappedHyperdash != null)
{
if (currentObject.MovementType == MovementType.HYPERDASH &&
!currentObject.IsHigherSnapped(Beatmap.Difficulty.Insane) &&
!basicSnappedHyperdash.IsSameSnap(currentObject))
{
yield return(new Issue(
GetTemplate("DifferentSnap"),
beatmap,
TimestampHelper.Get(basicSnappedHyperdash, currentObject)
).ForDifficulties(Beatmap.Difficulty.Insane));
}
basicSnappedHyperdash = null;
}
if (currentObject.NoteType == NoteType.HEAD)
{
// Check the if the last slider had more then 2 objects with hypers before continuing
if (sliderObjects.Count > 2)
{
yield return(new Issue(
GetTemplate("SliderHyperdashes"),
beatmap,
TimestampHelper.Get(sliderObjects.First()),
sliderObjects.Count
).ForDifficulties(Beatmap.Difficulty.Insane));
}
sliderObjects = new List <CatchHitObject>();
if (currentObject.MovementType == MovementType.HYPERDASH &&
!currentObject.IsHigherSnapped(Beatmap.Difficulty.Insane))
{
sliderObjects.Add(currentObject);
}
}
else if (currentObject.IsSlider)
{
if (currentObject.MovementType == MovementType.HYPERDASH &&
!currentObject.IsHigherSnapped(Beatmap.Difficulty.Insane))
{
sliderObjects.Add(currentObject);
}
}
if (currentObject.MovementType == MovementType.HYPERDASH &&
!currentObject.IsHigherSnapped(Beatmap.Difficulty.Insane))
{
basicSnappedHyperdash = currentObject;
}
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
CatchHitObject higherSnappedHyperdash = null;
foreach (var currentObject in catchObjects)
{
if (higherSnappedHyperdash != null)
{
// Hyperdashes that are higher-snapped must not be used in conjunction with any other hyperdashes.
if (currentObject.MovementType == MovementType.HYPERDASH)
{
yield return(new Issue(
GetTemplate("ConsecutiveHyperdashes"),
beatmap,
TimestampHelper.Get(higherSnappedHyperdash, currentObject)
).ForDifficulties(Beatmap.Difficulty.Insane));
}
else if (currentObject.MovementType == MovementType.DASH)
{
// Hyperdashes that are higher-snapped must not be used in conjunction with higher-snapped dashes.
if (currentObject.IsHigherSnapped(Beatmap.Difficulty.Insane) &&
higherSnappedHyperdash.TimeToTarget > 125) // Dash accuracy isn't correct at low ms
{
yield return(new Issue(
GetTemplate("HyperdashesWithHigherSnappedDashes"),
beatmap,
TimestampHelper.Get(higherSnappedHyperdash, currentObject, currentObject.Target)
).ForDifficulties(Beatmap.Difficulty.Insane));
}
// Hyperdashes that are higher-snapped should not be followed by antiflow dashes with a gap lower than 250ms.
if (higherSnappedHyperdash.NoteDirection != currentObject.NoteDirection)
{
if (currentObject.TimeToTarget < 250)
{
yield return(new Issue(
GetTemplate("HyperdashWithAntiFlowDash250"),
beatmap,
TimestampHelper.Get(higherSnappedHyperdash, currentObject, currentObject.Target)
).ForDifficulties(Beatmap.Difficulty.Insane));
}
}
}
}
if (currentObject.Target == null)
{
continue;
}
if (currentObject.MovementType == MovementType.HYPERDASH)
{
if (currentObject.IsHigherSnapped(Beatmap.Difficulty.Insane))
{
// Hyperdashes that are higher-snapped must not be used within a slider.
switch (currentObject.NoteType)
{
case NoteType.HEAD:
case NoteType.REPEAT:
case NoteType.DROPLET:
yield return(new Issue(
GetTemplate("HyperdashSlider"),
beatmap,
TimestampHelper.Get(currentObject, currentObject.Target)
).ForDifficulties(Beatmap.Difficulty.Insane));
break;
}
higherSnappedHyperdash = currentObject;
}
else
{
higherSnappedHyperdash = null;
}
}
else
{
higherSnappedHyperdash = null;
}
}
}
public override IEnumerable <Issue> GetIssues(Beatmap beatmap)
{
var catchObjects = CheckBeatmapSetDistanceCalculation.GetBeatmapDistances(beatmap);
var consecutiveObjects = new List <CatchHitObject>();
var checkForIssues = false;
foreach (var currentObject in catchObjects)
{
if (currentObject.MovementType == MovementType.DASH)
{
if (currentObject.IsHigherSnapped(Beatmap.Difficulty.Hard))
{
consecutiveObjects.Add(currentObject);
// Check for anti-flow if we have 2 consecutive higher-snapped dashes
if (consecutiveObjects.Count == 2)
{
var firstObject = consecutiveObjects[0];
var secondObject = consecutiveObjects[1];
if (firstObject.NoteDirection != secondObject.NoteDirection)
{
yield return(new Issue(
GetTemplate("HigherSnappedAntiFlowConsecutive"),
beatmap,
TimestampHelper.Get(consecutiveObjects.ToArray())
).ForDifficulties(Beatmap.Difficulty.Hard));
}
}
}
else
{
checkForIssues = true;
}
}
else
{
checkForIssues = true;
}
if (checkForIssues)
{
var totalConsecutiveHigherSnappedDashes = consecutiveObjects.Count;
consecutiveObjects.Add(currentObject);
if (totalConsecutiveHigherSnappedDashes > 2)
{
yield return(new Issue(
GetTemplate("HigherSnappedConsecutive"),
beatmap,
TimestampHelper.Get(consecutiveObjects.ToArray()),
2,
totalConsecutiveHigherSnappedDashes
).ForDifficulties(Beatmap.Difficulty.Hard));
}
// Reset all values after checking for potential issues
consecutiveObjects = new List <CatchHitObject>();
checkForIssues = false;
}
}
}
