private ConvertResult convert(string name)
{
var beatmap = getBeatmap(name);
var rulesetInstance = CreateRuleset();
beatmap.BeatmapInfo.Ruleset = beatmap.BeatmapInfo.RulesetID == rulesetInstance.RulesetInfo.ID ? rulesetInstance.RulesetInfo : new RulesetInfo();
Converter = rulesetInstance.CreateBeatmapConverter(beatmap);
var result = new ConvertResult();
Converter.ObjectConverted += (orig, converted) =>
{
converted.ForEach(h => h.ApplyDefaults(beatmap.ControlPointInfo, beatmap.BeatmapInfo.BaseDifficulty));
var mapping = CreateConvertMapping();
mapping.StartTime = orig.StartTime;
foreach (var obj in converted)
{
mapping.Objects.AddRange(CreateConvertValue(obj));
}
result.Mappings.Add(mapping);
};
IBeatmap convertedBeatmap = Converter.Convert();
rulesetInstance.CreateBeatmapProcessor(convertedBeatmap)?.PostProcess();
return(result);
}
public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
{
if (beatmapConverter is HexBeatmapConverter c)
{
c.CustomLaneCount = _lanes;
}
}
public IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList <Mod> mods)
{
var rulesetInstance = ruleset.CreateInstance();
IBeatmapConverter converter = CreateBeatmapConverter(Beatmap, rulesetInstance);
// Check if the beatmap can be converted
if (!converter.CanConvert)
{
throw new BeatmapInvalidForRulesetException($"{nameof(Beatmaps.Beatmap)} can not be converted for the ruleset (ruleset: {ruleset.InstantiationInfo}, converter: {converter}).");
}
// Apply conversion mods
foreach (var mod in mods.OfType <IApplicableToBeatmapConverter>())
{
mod.ApplyToBeatmapConverter(converter);
}
// Convert
IBeatmap converted = converter.Convert();
// Apply difficulty mods
if (mods.Any(m => m is IApplicableToDifficulty))
{
converted.BeatmapInfo = converted.BeatmapInfo.Clone();
converted.BeatmapInfo.BaseDifficulty = converted.BeatmapInfo.BaseDifficulty.Clone();
foreach (var mod in mods.OfType <IApplicableToDifficulty>())
{
mod.ApplyToDifficulty(converted.BeatmapInfo.BaseDifficulty);
}
}
IBeatmapProcessor processor = rulesetInstance.CreateBeatmapProcessor(converted);
processor?.PreProcess();
// Compute default values for hitobjects, including creating nested hitobjects in-case they're needed
foreach (var obj in converted.HitObjects)
{
obj.ApplyDefaults(converted.ControlPointInfo, converted.BeatmapInfo.BaseDifficulty);
}
foreach (var mod in mods.OfType <IApplicableToHitObject>())
{
foreach (var obj in converted.HitObjects)
{
mod.ApplyToHitObject(obj);
}
}
processor?.PostProcess();
foreach (var mod in mods.OfType <IApplicableToBeatmap>())
{
mod.ApplyToBeatmap(converted);
}
return(converted);
}
public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
{
var converter = (TauBeatmapConverter)beatmapConverter;
converter.CanConvertToSliders = !ToggleSliders.Value;
converter.CanConvertToHardBeats = !ToggleHardBeats.Value;
converter.SliderDivisionLevel = SlidersDivisionLevel.Value;
}
public CrossConvertMapping(IBeatmapConverter converter)
{
var crossConverter = (CrossBeatmapConverter)converter;
RandomW = crossConverter.Random.W;
RandomX = crossConverter.Random.X;
RandomY = crossConverter.Random.Y;
RandomZ = crossConverter.Random.Z;
}
public RngSnapshot(IBeatmapConverter converter)
{
var maniaConverter = (ManiaBeatmapConverter)converter;
RandomW = maniaConverter.Random.W;
RandomX = maniaConverter.Random.X;
RandomY = maniaConverter.Random.Y;
RandomZ = maniaConverter.Random.Z;
}
public ManiaConvertMapping(IBeatmapConverter converter)
{
var maniaConverter = (ManiaBeatmapConverter)converter;
RandomW = maniaConverter.Random.W;
RandomX = maniaConverter.Random.X;
RandomY = maniaConverter.Random.Y;
RandomZ = maniaConverter.Random.Z;
}
public RushBeatmapConverter(IBeatmap beatmap, Ruleset ruleset)
{
bool crafted = !string.IsNullOrEmpty(beatmap.Metadata.Tags) &&
beatmap.Metadata.Tags
.Split(" ")
.Any(tag => tag.Equals(CRAFTED_TAG, StringComparison.OrdinalIgnoreCase));
BackedConverter = crafted
? (IBeatmapConverter) new RushCraftedBeatmapConverter(beatmap, ruleset)
: new RushGeneratedBeatmapConverter(beatmap, ruleset);
}
public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
{
if (EnableTwinNotes.Value)
{
(beatmapConverter as SentakkiBeatmapConverter).EnabledExperiments.Value |= ConversionExperiments.twinNotes;
}
if (EnableTwinSlides.Value)
{
(beatmapConverter as SentakkiBeatmapConverter).EnabledExperiments.Value |= ConversionExperiments.twinSlides;
}
}
public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
{
var mbc = (ManiaBeatmapConverter)beatmapConverter;
// Although this can work, for now let's not allow keymods for mania-specific beatmaps
if (mbc.IsForCurrentRuleset)
{
return;
}
mbc.TargetColumns = KeyCount;
}
public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
{
var mbc = (ManiaBeatmapConverter)beatmapConverter;
isForCurrentRuleset = mbc.IsForCurrentRuleset;
// Although this can work, for now let's not allow keymods for mania-specific beatmaps
if (isForCurrentRuleset)
{
return;
}
mbc.Dual = true;
}
public virtual IBeatmap GetPlayableBeatmap(IRulesetInfo ruleset, IReadOnlyList <Mod> mods, CancellationToken token)
{
var rulesetInstance = ruleset.CreateInstance();
if (rulesetInstance == null)
{
throw new RulesetLoadException("Creating ruleset instance failed when attempting to create playable beatmap.");
}
IBeatmapConverter converter = CreateBeatmapConverter(Beatmap, rulesetInstance);
// Check if the beatmap can be converted
if (Beatmap.HitObjects.Count > 0 && !converter.CanConvert())
{
throw new BeatmapInvalidForRulesetException($"{nameof(Beatmaps.Beatmap)} can not be converted for the ruleset (ruleset: {ruleset.InstantiationInfo}, converter: {converter}).");
}
// Apply conversion mods
foreach (var mod in mods.OfType <IApplicableToBeatmapConverter>())
{
token.ThrowIfCancellationRequested();
mod.ApplyToBeatmapConverter(converter);
}
// Convert
IBeatmap converted = converter.Convert(token);
// Apply conversion mods to the result
foreach (var mod in mods.OfType <IApplicableAfterBeatmapConversion>())
{
token.ThrowIfCancellationRequested();
mod.ApplyToBeatmap(converted);
}
// Apply difficulty mods
if (mods.Any(m => m is IApplicableToDifficulty))
{
foreach (var mod in mods.OfType <IApplicableToDifficulty>())
{
token.ThrowIfCancellationRequested();
mod.ApplyToDifficulty(converted.Difficulty);
}
}
IBeatmapProcessor processor = rulesetInstance.CreateBeatmapProcessor(converted);
foreach (var mod in mods.OfType <IApplicableToBeatmapProcessor>())
{
mod.ApplyToBeatmapProcessor(processor);
}
processor?.PreProcess();
// Compute default values for hitobjects, including creating nested hitobjects in-case they're needed
foreach (var obj in converted.HitObjects)
{
token.ThrowIfCancellationRequested();
obj.ApplyDefaults(converted.ControlPointInfo, converted.Difficulty, token);
}
foreach (var mod in mods.OfType <IApplicableToHitObject>())
{
foreach (var obj in converted.HitObjects)
{
token.ThrowIfCancellationRequested();
mod.ApplyToHitObject(obj);
}
}
processor?.PostProcess();
foreach (var mod in mods.OfType <IApplicableToBeatmap>())
{
token.ThrowIfCancellationRequested();
mod.ApplyToBeatmap(converted);
}
return(converted);
}
public IBeatmap GetPlayableBeatmap(RulesetInfo ruleset, IReadOnlyList <Mod> mods = null, TimeSpan?timeout = null)
{
using (var cancellationSource = createCancellationTokenSource(timeout))
{
mods ??= Array.Empty <Mod>();
var rulesetInstance = ruleset.CreateInstance();
IBeatmapConverter converter = CreateBeatmapConverter(Beatmap, rulesetInstance);
// Check if the beatmap can be converted
if (Beatmap.HitObjects.Count > 0 && !converter.CanConvert())
{
throw new BeatmapInvalidForRulesetException($"{nameof(Beatmaps.Beatmap)} can not be converted for the ruleset (ruleset: {ruleset.InstantiationInfo}, converter: {converter}).");
}
// Apply conversion mods
foreach (var mod in mods.OfType <IApplicableToBeatmapConverter>())
{
if (cancellationSource.IsCancellationRequested)
{
throw new BeatmapLoadTimeoutException(BeatmapInfo);
}
mod.ApplyToBeatmapConverter(converter);
}
// Convert
IBeatmap converted = converter.Convert();
// Apply difficulty mods
if (mods.Any(m => m is IApplicableToDifficulty))
{
converted.BeatmapInfo = converted.BeatmapInfo.Clone();
converted.BeatmapInfo.BaseDifficulty = converted.BeatmapInfo.BaseDifficulty.Clone();
foreach (var mod in mods.OfType <IApplicableToDifficulty>())
{
if (cancellationSource.IsCancellationRequested)
{
throw new BeatmapLoadTimeoutException(BeatmapInfo);
}
mod.ApplyToDifficulty(converted.BeatmapInfo.BaseDifficulty);
}
}
IBeatmapProcessor processor = rulesetInstance.CreateBeatmapProcessor(converted);
processor?.PreProcess();
// Compute default values for hitobjects, including creating nested hitobjects in-case they're needed
foreach (var obj in converted.HitObjects)
{
if (cancellationSource.IsCancellationRequested)
{
throw new BeatmapLoadTimeoutException(BeatmapInfo);
}
obj.ApplyDefaults(converted.ControlPointInfo, converted.BeatmapInfo.BaseDifficulty);
}
foreach (var mod in mods.OfType <IApplicableToHitObject>())
{
foreach (var obj in converted.HitObjects)
{
if (cancellationSource.IsCancellationRequested)
{
throw new BeatmapLoadTimeoutException(BeatmapInfo);
}
mod.ApplyToHitObject(obj);
}
}
processor?.PostProcess();
foreach (var mod in mods.OfType <IApplicableToBeatmap>())
{
cancellationSource.Token.ThrowIfCancellationRequested();
mod.ApplyToBeatmap(converted);
}
return(converted);
}
}
protected override void OnConversionGenerated(HitObject original, IEnumerable <HitObject> result, IBeatmapConverter beatmapConverter)
{
base.OnConversionGenerated(original, result, beatmapConverter);
rngSnapshots[original] = new RngSnapshot(beatmapConverter);
}
public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
{
var bc = (DivaBeatmapConverter)beatmapConverter;
bc.AllowDoubles = false;
}
public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
{
var bosuBeatmapConverter = (BosuBeatmapConverter)beatmapConverter;
bosuBeatmapConverter.Symmetry = true;
}
public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
{
var bosuBeatmapConverter = (BosuBeatmapConverter)beatmapConverter;
bosuBeatmapConverter.SlidersOnly = true;
}
protected virtual void OnConversionGenerated(HitObject original, IEnumerable <HitObject> result, IBeatmapConverter beatmapConverter)
{
}
public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
{
ModCompatibility.ApplyMod(this, beatmapConverter);
}
public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
{
var bc = (DivaBeatmapConverter)beatmapConverter;
bc.TargetButtons = KeyCount;
}
public void ApplyToBeatmapConverter(IBeatmapConverter beatmapConverter)
{
(beatmapConverter as SentakkiBeatmapConverter).Experimental = true;
}
