protected override void CheckForJudgements(bool userTriggered, double timeOffset)
{
if (userTriggered)
{
return;
}
if (timeOffset < 0)
{
return;
}
int countHit = NestedHitObjects.Count(o => o.AllJudged);
if (countHit > HitObject.RequiredGoodHits)
{
AddJudgement(new TaikoJudgement {
Result = countHit >= HitObject.RequiredGreatHits ? HitResult.Great : HitResult.Good
});
if (HitObject.IsStrong)
{
AddJudgement(new TaikoStrongHitJudgement());
}
}
else
{
AddJudgement(new TaikoJudgement {
Result = HitResult.Miss
});
}
}
protected override void CheckForResult(bool userTriggered, double timeOffset)
{
if (userTriggered || Time.Current < slider.EndTime)
{
return;
}
ApplyResult(r =>
{
var judgementsCount = NestedHitObjects.Count();
var judgementsHit = NestedHitObjects.Count(h => h.IsHit);
var hitFraction = (double)judgementsHit / judgementsCount;
if (hitFraction == 1 && HeadCircle.Result.Type == HitResult.Great)
{
r.Type = HitResult.Great;
}
else if (hitFraction >= 0.5 && HeadCircle.Result.Type >= HitResult.Good)
{
r.Type = HitResult.Good;
}
else if (hitFraction > 0)
{
r.Type = HitResult.Meh;
}
else
{
r.Type = HitResult.Miss;
}
});
}
protected override void CheckForJudgements(bool userTriggered, double timeOffset)
{
if (!userTriggered && Time.Current >= slider.EndTime)
{
var judgementsCount = NestedHitObjects.Count;
var judgementsHit = NestedHitObjects.Count(h => h.IsHit);
var hitFraction = (double)judgementsHit / judgementsCount;
if (hitFraction == 1 && HeadCircle.Judgements.Any(j => j.Result == HitResult.Great))
{
AddJudgement(new OsuJudgement {
Result = HitResult.Great
});
}
else if (hitFraction >= 0.5 && HeadCircle.Judgements.Any(j => j.Result >= HitResult.Good))
{
AddJudgement(new OsuJudgement {
Result = HitResult.Good
});
}
else if (hitFraction > 0)
{
AddJudgement(new OsuJudgement {
Result = HitResult.Meh
});
}
else
{
AddJudgement(new OsuJudgement {
Result = HitResult.Miss
});
}
}
}
protected override void CheckForResult(bool userTriggered, double timeOffset)
{
if (userTriggered)
return;
if (timeOffset < 0)
return;
int countHit = NestedHitObjects.Count(o => o.IsHit);
if (countHit >= HitObject.RequiredGoodHits)
ApplyResult(r => r.Type = countHit >= HitObject.RequiredGreatHits ? HitResult.Great : HitResult.Good);
else
ApplyResult(r => r.Type = HitResult.Miss);
}
protected override void CheckForResult(bool userTriggered, double timeOffset)
{
if (userTriggered)
{
return;
}
if (timeOffset < 0)
{
return;
}
int countHit = NestedHitObjects.Count(o => o.IsHit);
if (countHit >= HitObject.RequiredGoodHits)
{
ApplyResult(r => r.Type = countHit >= HitObject.RequiredGreatHits ? HitResult.Great : HitResult.Ok);
}
else
{
ApplyResult(r => r.Type = r.Judgement.MinResult);
}
}
protected override void CheckJudgement(bool userTriggered)
{
if (userTriggered)
{
return;
}
if (Judgement.TimeOffset < 0)
{
return;
}
int countHit = NestedHitObjects.Count(o => o.Judgement.Result == HitResult.Hit);
if (countHit > HitObject.RequiredGoodHits)
{
Judgement.Result = HitResult.Hit;
Judgement.TaikoResult = countHit >= HitObject.RequiredGreatHits ? TaikoHitResult.Great : TaikoHitResult.Good;
}
else
{
Judgement.Result = HitResult.Miss;
}
}
protected override void CheckForResult(bool userTriggered, double timeOffset)
{
if (userTriggered || Time.Current < HitObject.EndTime)
{
return;
}
// If only the nested hitobjects are judged, then the slider's own judgement is ignored for scoring purposes.
// But the slider needs to still be judged with a reasonable hit/miss result for visual purposes (hit/miss transforms, etc).
if (HitObject.OnlyJudgeNestedObjects)
{
ApplyResult(r => r.Type = NestedHitObjects.Any(h => h.Result.IsHit) ? r.Judgement.MaxResult : r.Judgement.MinResult);
return;
}
// Otherwise, if this slider also needs to be judged, apply judgement proportionally to the number of nested hitobjects hit. This is the classic osu!stable scoring.
ApplyResult(r =>
{
int totalTicks = NestedHitObjects.Count;
int hitTicks = NestedHitObjects.Count(h => h.IsHit);
if (hitTicks == totalTicks)
{
r.Type = HitResult.Great;
}
else if (hitTicks == 0)
{
r.Type = HitResult.Miss;
}
else
{
double hitFraction = (double)hitTicks / totalTicks;
r.Type = hitFraction >= 0.5 ? HitResult.Ok : HitResult.Meh;
}
});
}