1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-20 00:52:55 +08:00
osu-lazer/osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

286 lines
10 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
2022-06-17 15:37:17 +08:00
#nullable disable
2017-04-18 15:05:58 +08:00
using osu.Game.Rulesets.Mania.Objects;
2017-04-17 14:44:46 +08:00
using System;
using System.Linq;
using System.Collections.Generic;
using System.Threading;
using osu.Game.Audio;
using osu.Game.Beatmaps;
2017-04-18 15:05:58 +08:00
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Objects.Types;
2017-05-19 15:31:05 +08:00
using osu.Game.Rulesets.Mania.Beatmaps.Patterns;
using osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy;
using osu.Game.Utils;
2018-11-20 15:51:59 +08:00
using osuTK;
2018-04-13 17:19:50 +08:00
2017-04-18 15:05:58 +08:00
namespace osu.Game.Rulesets.Mania.Beatmaps
2017-03-11 23:34:21 +08:00
{
public class ManiaBeatmapConverter : BeatmapConverter<ManiaHitObject>
2017-03-11 23:34:21 +08:00
{
/// <summary>
/// Maximum number of previous notes to consider for density calculation.
/// </summary>
private const int max_notes_for_density = 7;
2018-04-13 17:19:50 +08:00
public int TargetColumns;
2019-02-28 22:40:03 +08:00
public bool Dual;
public readonly bool IsForCurrentRuleset;
2018-04-13 17:19:50 +08:00
2020-10-14 19:40:17 +08:00
private readonly int originalTargetColumns;
2018-06-15 19:52:09 +08:00
// Internal for testing purposes
internal LegacyRandom Random { get; private set; }
2018-06-15 19:52:09 +08:00
2017-05-19 15:31:05 +08:00
private Pattern lastPattern = new Pattern();
2018-04-13 17:19:50 +08:00
private ManiaBeatmap beatmap;
2018-04-13 17:19:50 +08:00
public ManiaBeatmapConverter(IBeatmap beatmap, Ruleset ruleset)
: base(beatmap, ruleset)
2017-03-11 23:34:21 +08:00
{
IsForCurrentRuleset = beatmap.BeatmapInfo.Ruleset.Equals(ruleset.RulesetInfo);
2018-05-07 10:23:29 +08:00
double roundedCircleSize = Math.Round(beatmap.Difficulty.CircleSize);
double roundedOverallDifficulty = Math.Round(beatmap.Difficulty.OverallDifficulty);
2018-04-13 17:19:50 +08:00
2018-05-07 08:17:12 +08:00
if (IsForCurrentRuleset)
2019-02-28 18:07:43 +08:00
{
TargetColumns = GetColumnCountForNonConvert(beatmap.BeatmapInfo);
2019-04-01 11:16:05 +08:00
2020-04-21 09:56:04 +08:00
if (TargetColumns > ManiaRuleset.MAX_STAGE_KEYS)
2019-02-28 18:07:43 +08:00
{
2019-11-12 17:56:38 +08:00
TargetColumns /= 2;
2019-02-28 22:40:03 +08:00
Dual = true;
2019-02-28 18:07:43 +08:00
}
}
else
{
2020-05-27 11:38:39 +08:00
float percentSliderOrSpinner = (float)beatmap.HitObjects.Count(h => h is IHasDuration) / beatmap.HitObjects.Count;
if (percentSliderOrSpinner < 0.2)
TargetColumns = 7;
2018-01-04 18:52:29 +08:00
else if (percentSliderOrSpinner < 0.3 || roundedCircleSize >= 5)
TargetColumns = roundedOverallDifficulty > 5 ? 7 : 6;
else if (percentSliderOrSpinner > 0.6)
2018-01-04 18:52:29 +08:00
TargetColumns = roundedOverallDifficulty > 4 ? 5 : 4;
else
2018-01-04 18:52:29 +08:00
TargetColumns = Math.Max(4, Math.Min((int)roundedOverallDifficulty + 1, 7));
}
originalTargetColumns = TargetColumns;
}
2018-04-13 17:19:50 +08:00
2021-10-02 23:55:29 +08:00
public static int GetColumnCountForNonConvert(BeatmapInfo beatmapInfo)
{
double roundedCircleSize = Math.Round(beatmapInfo.Difficulty.CircleSize);
return (int)Math.Max(1, roundedCircleSize);
}
public override bool CanConvert() => Beatmap.HitObjects.All(h => h is IHasXPosition);
protected override Beatmap<ManiaHitObject> ConvertBeatmap(IBeatmap original, CancellationToken cancellationToken)
{
IBeatmapDifficultyInfo difficulty = original.Difficulty;
2018-04-13 17:19:50 +08:00
int seed = (int)MathF.Round(difficulty.DrainRate + difficulty.CircleSize) * 20 + (int)(difficulty.OverallDifficulty * 41.2) + (int)MathF.Round(difficulty.ApproachRate);
Random = new LegacyRandom(seed);
2018-04-13 17:19:50 +08:00
return base.ConvertBeatmap(original, cancellationToken);
2017-03-11 23:34:21 +08:00
}
2018-04-13 17:19:50 +08:00
2019-02-28 18:07:43 +08:00
protected override Beatmap<ManiaHitObject> CreateBeatmap()
{
beatmap = new ManiaBeatmap(new StageDefinition(TargetColumns), originalTargetColumns);
2019-02-28 18:07:43 +08:00
2019-03-01 13:30:58 +08:00
if (Dual)
beatmap.Stages.Add(new StageDefinition(TargetColumns));
2019-02-28 18:07:43 +08:00
return beatmap;
}
2018-04-13 17:19:50 +08:00
protected override IEnumerable<ManiaHitObject> ConvertHitObject(HitObject original, IBeatmap beatmap, CancellationToken cancellationToken)
{
2019-02-28 13:35:00 +08:00
if (original is ManiaHitObject maniaOriginal)
{
yield return maniaOriginal;
2019-02-28 12:31:40 +08:00
yield break;
}
2018-04-13 17:19:50 +08:00
var objects = IsForCurrentRuleset ? generateSpecific(original, beatmap) : generateConverted(original, beatmap);
2018-04-13 17:19:50 +08:00
2017-05-19 15:31:05 +08:00
if (objects == null)
yield break;
2018-04-13 17:19:50 +08:00
2017-05-19 15:31:05 +08:00
foreach (ManiaHitObject obj in objects)
yield return obj;
}
2018-04-13 17:19:50 +08:00
2017-05-22 12:43:53 +08:00
private readonly List<double> prevNoteTimes = new List<double>(max_notes_for_density);
private double density = int.MaxValue;
2019-02-28 12:31:40 +08:00
private void computeDensity(double newNoteTime)
{
if (prevNoteTimes.Count == max_notes_for_density)
prevNoteTimes.RemoveAt(0);
prevNoteTimes.Add(newNoteTime);
2018-04-13 17:19:50 +08:00
2020-10-09 20:11:12 +08:00
if (prevNoteTimes.Count >= 2)
density = (prevNoteTimes[^1] - prevNoteTimes[0]) / prevNoteTimes.Count;
}
2018-04-13 17:19:50 +08:00
private double lastTime;
private Vector2 lastPosition;
2018-06-15 21:08:24 +08:00
private PatternType lastStair = PatternType.Stair;
2019-02-28 12:31:40 +08:00
private void recordNote(double time, Vector2 position)
{
lastTime = time;
lastPosition = position;
}
2018-04-13 17:19:50 +08:00
2017-05-19 15:39:02 +08:00
/// <summary>
/// Method that generates hit objects for osu!mania specific beatmaps.
/// </summary>
/// <param name="original">The original hit object.</param>
/// <param name="originalBeatmap">The original beatmap. This is used to look-up any values dependent on a fully-loaded beatmap.</param>
2017-05-19 15:39:02 +08:00
/// <returns>The hit objects generated.</returns>
2018-04-19 19:44:38 +08:00
private IEnumerable<ManiaHitObject> generateSpecific(HitObject original, IBeatmap originalBeatmap)
2017-05-19 15:31:05 +08:00
{
2018-06-15 19:52:09 +08:00
var generator = new SpecificBeatmapPatternGenerator(Random, original, beatmap, lastPattern, originalBeatmap);
2018-04-13 17:19:50 +08:00
foreach (var newPattern in generator.Generate())
{
lastPattern = newPattern;
2018-04-13 17:19:50 +08:00
foreach (var obj in newPattern.HitObjects)
yield return obj;
}
2017-05-19 15:31:05 +08:00
}
2018-04-13 17:19:50 +08:00
2017-05-19 15:39:02 +08:00
/// <summary>
/// Method that generates hit objects for non-osu!mania beatmaps.
/// </summary>
/// <param name="original">The original hit object.</param>
/// <param name="originalBeatmap">The original beatmap. This is used to look-up any values dependent on a fully-loaded beatmap.</param>
2017-05-19 15:39:02 +08:00
/// <returns>The hit objects generated.</returns>
2018-04-19 19:44:38 +08:00
private IEnumerable<ManiaHitObject> generateConverted(HitObject original, IBeatmap originalBeatmap)
2017-05-19 15:31:05 +08:00
{
Patterns.PatternGenerator conversion = null;
2018-04-13 17:19:50 +08:00
2019-11-12 18:16:51 +08:00
switch (original)
2018-06-15 19:52:09 +08:00
{
2022-06-24 20:25:23 +08:00
case IHasDistance:
2019-11-12 18:16:51 +08:00
{
var generator = new DistanceObjectPatternGenerator(Random, original, beatmap, lastPattern, originalBeatmap);
conversion = generator;
var positionData = original as IHasPosition;
for (int i = 0; i <= generator.SpanCount; i++)
2019-11-12 18:16:51 +08:00
{
double time = original.StartTime + generator.SegmentDuration * i;
2019-11-12 18:16:51 +08:00
recordNote(time, positionData?.Position ?? Vector2.Zero);
computeDensity(time);
}
2018-06-15 19:52:36 +08:00
2019-11-12 18:16:51 +08:00
break;
}
2020-05-27 11:38:39 +08:00
case IHasDuration endTimeData:
2018-06-15 19:52:36 +08:00
{
conversion = new EndTimeObjectPatternGenerator(Random, original, beatmap, lastPattern, originalBeatmap);
2019-11-12 18:16:51 +08:00
recordNote(endTimeData.EndTime, new Vector2(256, 192));
computeDensity(endTimeData.EndTime);
break;
2018-06-15 19:52:36 +08:00
}
2019-11-12 18:16:51 +08:00
case IHasPosition positionData:
{
computeDensity(original.StartTime);
2018-04-13 17:19:50 +08:00
2019-11-12 18:16:51 +08:00
conversion = new HitObjectPatternGenerator(Random, original, beatmap, lastPattern, lastTime, lastPosition, density, lastStair, originalBeatmap);
2018-04-13 17:19:50 +08:00
2019-11-12 18:16:51 +08:00
recordNote(original.StartTime, positionData.Position);
break;
}
2017-05-19 15:31:05 +08:00
}
2018-04-13 17:19:50 +08:00
if (conversion == null)
yield break;
2018-04-13 17:19:50 +08:00
foreach (var newPattern in conversion.Generate())
{
lastPattern = conversion is EndTimeObjectPatternGenerator ? lastPattern : newPattern;
lastStair = (conversion as HitObjectPatternGenerator)?.StairType ?? lastStair;
2018-04-13 17:19:50 +08:00
foreach (var obj in newPattern.HitObjects)
yield return obj;
}
2017-05-19 15:31:05 +08:00
}
2018-04-13 17:19:50 +08:00
2017-05-19 15:31:05 +08:00
/// <summary>
2017-05-19 15:39:02 +08:00
/// A pattern generator for osu!mania-specific beatmaps.
2017-05-19 15:31:05 +08:00
/// </summary>
private class SpecificBeatmapPatternGenerator : Patterns.Legacy.PatternGenerator
{
public SpecificBeatmapPatternGenerator(LegacyRandom random, HitObject hitObject, ManiaBeatmap beatmap, Pattern previousPattern, IBeatmap originalBeatmap)
: base(random, hitObject, beatmap, previousPattern, originalBeatmap)
2017-05-19 15:31:05 +08:00
{
}
2018-04-13 17:19:50 +08:00
public override IEnumerable<Pattern> Generate()
{
yield return generate();
}
private Pattern generate()
2017-05-19 15:31:05 +08:00
{
var positionData = HitObject as IHasXPosition;
2018-04-13 17:19:50 +08:00
2017-05-19 15:31:05 +08:00
int column = GetColumn(positionData?.X ?? 0);
2018-04-13 17:19:50 +08:00
2017-05-19 15:31:05 +08:00
var pattern = new Pattern();
2018-04-13 17:19:50 +08:00
2020-05-27 11:38:39 +08:00
if (HitObject is IHasDuration endTimeData)
2017-05-19 15:31:05 +08:00
{
pattern.Add(new HoldNote
{
StartTime = HitObject.StartTime,
Duration = endTimeData.Duration,
2020-04-22 12:45:12 +08:00
Column = column,
2020-04-21 15:33:19 +08:00
Samples = HitObject.Samples,
NodeSamples = (HitObject as IHasRepeats)?.NodeSamples ?? defaultNodeSamples
2017-05-19 15:31:05 +08:00
});
}
2019-11-12 18:16:51 +08:00
else if (HitObject is IHasXPosition)
2017-05-19 15:31:05 +08:00
{
pattern.Add(new Note
{
StartTime = HitObject.StartTime,
Samples = HitObject.Samples,
Column = column
});
}
2018-04-13 17:19:50 +08:00
2017-05-19 15:31:05 +08:00
return pattern;
}
/// <remarks>
/// osu!mania-specific beatmaps in stable only play samples at the start of the hold note.
/// </remarks>
private List<IList<HitSampleInfo>> defaultNodeSamples
=> new List<IList<HitSampleInfo>>
{
HitObject.Samples,
new List<HitSampleInfo>()
};
}
2017-03-11 23:34:21 +08:00
}
}