osu!taiko

public class Hit : TaikoStrongableHitObject, IHasDisplayColour
{
    public HitType Type { get; set; }  // Centre or Rim
    public Bindable<Color4> DisplayColour { get; } = new Bindable<Color4>(COLOUR_CENTRE);
    
    public static readonly Color4 COLOUR_CENTRE = Color4Extensions.FromHex(@"bb1177");  // Red/Pink
    public static readonly Color4 COLOUR_RIM = Color4Extensions.FromHex(@"2299bb");     // Blue
}

private void updateTypeFromSamples()
{
    Type = getRimSamples().Any() ? HitType.Rim : HitType.Centre;
}

private HitSampleInfo[] getRimSamples() => Samples
    .Where(s => s.Name == HitSampleInfo.HIT_CLAP || s.Name == HitSampleInfo.HIT_WHISTLE)
    .ToArray();

protected override StrongNestedHitObject CreateStrongNestedHit(double startTime) 
    => new StrongNestedHit(this)
{
    StartTime = startTime,
    Samples = Samples
};

public class DrumRoll : TaikoStrongableHitObject, IHasPath
{
    public double Duration { get; set; }
    public double Velocity { get; private set; }
    public int TickRate = 1;  // Ticks per beat
    private double tickSpacing = 100;  // Time between ticks
}

protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, 
                                           IBeatmapDifficultyInfo difficulty)
{
    base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
    
    TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
    EffectControlPoint effectPoint = controlPointInfo.EffectPointAt(StartTime);
    
    double scoringDistance = base_distance 
        * (difficulty.SliderMultiplier * TaikoBeatmapConverter.VELOCITY_MULTIPLIER) 
        * effectPoint.ScrollSpeed;
    Velocity = scoringDistance / timingPoint.BeatLength;
    
    TickRate = difficulty.SliderTickRate == 3 ? 3 : 4;
    tickSpacing = timingPoint.BeatLength / TickRate;
}

private void createTicks(CancellationToken cancellationToken)
{
    if (tickSpacing == 0)
        return;
    
    bool first = true;
    
    for (double t = StartTime; t < EndTime + tickSpacing / 2; t += tickSpacing)
    {
        cancellationToken.ThrowIfCancellationRequested();
        
        AddNested(new DrumRollTick(this)
        {
            FirstTick = first,
            TickSpacing = tickSpacing,
            StartTime = t,
            IsStrong = IsStrong,
            Samples = Samples
        });
        
        first = false;
    }
}

public class Swell : TaikoHitObject, IHasDuration
{
    public double Duration { get; set; }
    public int RequiredHits = 10;  // Number of hits needed
}

protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
{
    base.CreateNestedHitObjects(cancellationToken);
    
    for (int i = 0; i < RequiredHits; i++)
    {
        cancellationToken.ThrowIfCancellationRequested();
        AddNested(new SwellTick
        {
            StartTime = StartTime,
            Samples = Samples
        });
    }
}

public override IEnumerable<HitResult> GetValidHitResults()
{
    return new[]
    {
        HitResult.Great,      // Perfect hit (within great window)
        HitResult.Ok,         // Good hit (within ok window)
        HitResult.Miss,       // Missed or hit too early/late
        
        HitResult.SmallBonus, // Drum roll tick hit
        HitResult.LargeBonus, // Strong hit bonus
        HitResult.IgnoreHit,
        HitResult.IgnoreMiss,
    };
}

Accuracy = (0.5×nOk + 1.0×nGreat) / (nOk + nGreat + nMiss)

var hitWindows = new TaikoHitWindows();
hitWindows.SetDifficulty(modAdjustedDifficulty.OverallDifficulty);
double rate = ModUtils.CalculateRateWithMods(mods);

yield return new RulesetBeatmapAttribute("Accuracy", @"OD", 
    originalDifficulty.OverallDifficulty, 
    effectiveDifficulty.OverallDifficulty, 10)
{
    Description = "Affects timing requirements for hits and mash rate requirements for swells.",
    AdditionalMetrics = hitWindows.GetAllAvailableWindows()
        .Reverse()
        .Select(window => new RulesetBeatmapAttribute.AdditionalMetric(
            $"{window.result.GetDescription().ToUpperInvariant()} hit window",
            LocalisableString.Interpolate($@"±{hitWindows.WindowFor(window.result) / rate:0.##} ms"),
            colours.ForHitResult(window.result)
        ))
        .Append(new RulesetBeatmapAttribute.AdditionalMetric(
            "Hits per second required to clear swells", 
            LocalisableString.Interpolate(
                $@"{TaikoBeatmapConverter.RequiredSwellHitsPerSecond(
                    modAdjustedDifficulty.OverallDifficulty):0.#}"
            )
        ))
};

yield return new RulesetBeatmapAttribute("Scroll Speed", @"SS", 1f, 
    (float)(effectiveDifficulty.SliderMultiplier / originalDifficulty.SliderMultiplier), 4)
{
    Description = "Multiplier applied to the baseline scroll speed of the playfield when no mods are active."
};

public override IEnumerable<KeyBinding> GetDefaultKeyBindings(int variant = 0) => new[]
{
    new KeyBinding(InputKey.MouseRight, TaikoAction.LeftRim),
    new KeyBinding(InputKey.D, TaikoAction.LeftRim),
    new KeyBinding(InputKey.MouseLeft, TaikoAction.LeftCentre),
    new KeyBinding(InputKey.F, TaikoAction.LeftCentre),
    new KeyBinding(InputKey.J, TaikoAction.RightCentre),
    new KeyBinding(InputKey.K, TaikoAction.RightRim),
};

public override Judgement CreateJudgement() => new IgnoreJudgement();

public class StrongNestedHit : StrongNestedHitObject
{
    // The strong hit of the drum roll doesn't provide score
    public override Judgement CreateJudgement() => new IgnoreJudgement();
    
    public StrongNestedHit(TaikoHitObject parent) : base(parent) { }
}

public const double VELOCITY_MULTIPLIER = 1.4;