1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-15 09:02:55 +08:00
osu-lazer/osu.Game.Rulesets.Taiko/Objects/DrumRoll.cs

128 lines
4.3 KiB
C#
Raw Normal View History

// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
2018-04-13 17:19:50 +08:00
using osu.Game.Rulesets.Objects.Types;
using System;
using System.Threading;
2018-04-13 17:19:50 +08:00
using osu.Game.Beatmaps;
using osu.Game.Beatmaps.ControlPoints;
2018-11-29 09:56:19 +08:00
using osu.Game.Rulesets.Judgements;
2020-04-21 15:45:01 +08:00
using osu.Game.Rulesets.Objects;
2019-09-06 14:24:00 +08:00
using osu.Game.Rulesets.Scoring;
2020-04-21 15:45:01 +08:00
using osu.Game.Rulesets.Taiko.Beatmaps;
2018-11-29 09:56:19 +08:00
using osu.Game.Rulesets.Taiko.Judgements;
2020-04-21 15:45:01 +08:00
using osuTK;
2018-04-13 17:19:50 +08:00
namespace osu.Game.Rulesets.Taiko.Objects
{
2020-12-15 04:46:02 +08:00
public class DrumRoll : TaikoStrongableHitObject, IHasPath
2018-04-13 17:19:50 +08:00
{
/// <summary>
/// Drum roll distance that results in a duration of 1 speed-adjusted beat length.
/// </summary>
private const float base_distance = 100;
2020-02-05 16:12:26 +08:00
public double EndTime
{
get => StartTime + Duration;
set => Duration = value - StartTime;
}
2018-04-13 17:19:50 +08:00
public double Duration { get; set; }
2020-04-21 15:45:01 +08:00
/// <summary>
/// Velocity of this <see cref="DrumRoll"/>.
/// </summary>
public double Velocity { get; private set; }
2018-04-13 17:19:50 +08:00
/// <summary>
/// Numer of ticks per beat length.
/// </summary>
public int TickRate = 1;
/// <summary>
/// Number of drum roll ticks required for a "Good" hit.
/// </summary>
public double RequiredGoodHits { get; protected set; }
/// <summary>
/// Number of drum roll ticks required for a "Great" hit.
/// </summary>
public double RequiredGreatHits { get; protected set; }
/// <summary>
/// The length (in milliseconds) between ticks of this drumroll.
/// <para>Half of this value is the hit window of the ticks.</para>
/// </summary>
private double tickSpacing = 100;
private float overallDifficulty = BeatmapDifficulty.DEFAULT_DIFFICULTY;
2018-04-13 17:19:50 +08:00
protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
{
base.ApplyDefaultsToSelf(controlPointInfo, difficulty);
TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
2020-04-21 15:45:01 +08:00
DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime);
double scoringDistance = base_distance * difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier;
Velocity = scoringDistance / timingPoint.BeatLength;
2018-04-13 17:19:50 +08:00
tickSpacing = timingPoint.BeatLength / TickRate;
overallDifficulty = difficulty.OverallDifficulty;
2018-04-13 17:19:50 +08:00
}
protected override void CreateNestedHitObjects(CancellationToken cancellationToken)
2018-04-13 17:19:50 +08:00
{
createTicks(cancellationToken);
RequiredGoodHits = NestedHitObjects.Count * Math.Min(0.15, 0.05 + 0.10 / 6 * overallDifficulty);
RequiredGreatHits = NestedHitObjects.Count * Math.Min(0.30, 0.10 + 0.20 / 6 * overallDifficulty);
base.CreateNestedHitObjects(cancellationToken);
2018-04-13 17:19:50 +08:00
}
private void createTicks(CancellationToken cancellationToken)
2018-04-13 17:19:50 +08:00
{
if (tickSpacing == 0)
return;
bool first = true;
2019-04-01 11:16:05 +08:00
2018-04-13 17:19:50 +08:00
for (double t = StartTime; t < EndTime + tickSpacing / 2; t += tickSpacing)
{
cancellationToken.ThrowIfCancellationRequested();
2018-04-13 17:19:50 +08:00
AddNested(new DrumRollTick
{
FirstTick = first,
TickSpacing = tickSpacing,
StartTime = t,
IsStrong = IsStrong
});
first = false;
}
}
2018-12-06 16:09:42 +08:00
public override Judgement CreateJudgement() => new TaikoDrumRollJudgement();
2019-10-09 18:08:31 +08:00
protected override HitWindows CreateHitWindows() => HitWindows.Empty;
2020-04-21 15:45:01 +08:00
2020-12-13 19:59:46 +08:00
protected override StrongNestedHitObject CreateStrongNestedHit(double startTime) => new StrongNestedHit { StartTime = startTime };
public class StrongNestedHit : StrongNestedHitObject
{
}
2020-04-21 15:45:01 +08:00
#region LegacyBeatmapEncoder
double IHasDistance.Distance => Duration * Velocity;
SliderPath IHasPath.Path
2020-04-21 15:45:01 +08:00
=> new SliderPath(PathType.Linear, new[] { Vector2.Zero, new Vector2(1) }, ((IHasDistance)this).Distance / TaikoBeatmapConverter.LEGACY_VELOCITY_MULTIPLIER);
#endregion
2018-04-13 17:19:50 +08:00
}
}