private async void ServiceDiffCalcRequest()
{
// acquire mutually exclusive entry into this method
serviceDiffCalcRequestLocked = true;
decimal stars = 0.0M, aim = 0.0M, speed = 0.0M;
while (completedDiffCalcRequest == null || completedDiffCalcRequest.RequestNumber != diffCalcRequests.Last().RequestNumber)
{
completedDiffCalcRequest = diffCalcRequests.Last();
try
{
(stars, aim, speed) = await Task.Run(() => DifficultyCalculator.CalculateStarRating(NewBeatmap));
}
catch (Exception e)
{
Console.WriteLine(e);
Console.WriteLine("lol asdfasdf;lkjasdf");
(stars, aim, speed) = (0, 0, 0);
}
// if a new request came in, invalidate the diffcalc result and service the new request
}
// we serviced the last request, so we can commit to the diffcalc result
StarRating = stars;
AimRating = aim;
SpeedRating = speed;
BeatmapModified?.Invoke(this, EventArgs.Empty);
serviceDiffCalcRequestLocked = false;
}
public void SetBpmMultiplier(float multiplier)
{
BpmMultiplier = multiplier;
// make no changes
if (State == EditorState.NOT_READY)
{
return;
}
// scale AR
if (ScaleAR && !ArIsLocked)
{
NewBeatmap.ApproachRate = DifficultyCalculator.CalculateMultipliedAR(OriginalBeatmap, BpmMultiplier);
}
// scale OD
if (ScaleOD && !OdIsLocked)
{
NewBeatmap.OverallDifficulty = DifficultyCalculator.CalculateMultipliedOD(OriginalBeatmap, BpmMultiplier);
}
// modify beatmap timing
ModifyBeatmapTiming(OriginalBeatmap, NewBeatmap, BpmMultiplier);
RequestDiffCalc();
BeatmapModified?.Invoke(this, EventArgs.Empty);
}
public void GenerateBeatmap()
{
if (State != EditorState.READY)
{
return;
}
SetState(EditorState.GENERATING_BEATMAP);
bool compensateForDT = (NewBeatmap.ApproachRate > 10 || NewBeatmap.OverallDifficulty > 10);
// Set metadata
Beatmap exportBeatmap = new Beatmap(NewBeatmap);
ModifyBeatmapMetadata(exportBeatmap, BpmMultiplier, ChangePitch, compensateForDT);
if (NoSpinners)
{
exportBeatmap.RemoveSpinners();
}
// Slow down map by 1.5x
if (compensateForDT)
{
exportBeatmap.ApproachRate = DifficultyCalculator.CalculateMultipliedAR(NewBeatmap, 1 / 1.5M);
exportBeatmap.OverallDifficulty = DifficultyCalculator.CalculateMultipliedOD(NewBeatmap, 1 / 1.5M);
decimal compensatedRate = (NewBeatmap.Bpm / OriginalBeatmap.Bpm) / 1.5M;
exportBeatmap.SetRate(compensatedRate);
}
// Generate new mp3
var audioFilePath = Path.Combine(JunUtils.GetBeatmapDirectoryName(OriginalBeatmap), exportBeatmap.AudioFilename);
var newMp3 = "";
if (!File.Exists(audioFilePath))
{
string inFile = Path.Combine(Path.GetDirectoryName(OriginalBeatmap.Filename), OriginalBeatmap.AudioFilename);
string outFile = Path.Combine(Path.GetTempPath(), exportBeatmap.AudioFilename);
SongSpeedChanger.GenerateAudioFile(inFile, outFile, BpmMultiplier, mainform.BackgroundWorker, ChangePitch, compensateForDT);
newMp3 = outFile;
// take note of this mp3 in a text file, so we can clean it up later
string mp3ManifestFile = GetMp3ListFilePath();
List <string> manifest = File.ReadAllLines(mp3ManifestFile).ToList();
string beatmapFolder = Path.GetDirectoryName(exportBeatmap.Filename).Replace(Properties.Settings.Default.SongsFolder + "\\", "");
string mp3RelativePath = Path.Combine(beatmapFolder, exportBeatmap.AudioFilename);
manifest.Add(mp3RelativePath + " | " + exportBeatmap.Filename);
File.WriteAllLines(mp3ManifestFile, manifest);
}
// save file to temp location (do not directly put into any song folder)
exportBeatmap.Filename = Path.Combine(Path.GetTempPath(), Path.GetFileName(exportBeatmap.Filename));
exportBeatmap.Save();
// create and execute osz
AddNewBeatmapToSongFolder(Path.GetDirectoryName(OriginalBeatmap.Filename), exportBeatmap.Filename, newMp3);
// post
SetState(EditorState.READY);
}
public void SetScaleOD(bool value)
{
ScaleOD = value;
if (State == EditorState.NOT_READY)
{
return;
}
if (ScaleOD)
{
NewBeatmap.OverallDifficulty = DifficultyCalculator.CalculateMultipliedOD(OriginalBeatmap, BpmMultiplier);
BeatmapModified?.Invoke(this, EventArgs.Empty);
}
ArIsLocked = false;
ControlsModified?.Invoke(this, EventArgs.Empty);
}
private async void ServiceBeatmapChangeRequest()
{
// acquire mutually exclusive entry into this method
serviceBeatmapRequestLocked = true;
Beatmap candidateOriginalBeatmap = null, candidateNewBeatmap = null;
while (completedBeatmapRequest == null || completedBeatmapRequest.RequestNumber != mapChangeRequests.Last().RequestNumber)
{
completedBeatmapRequest = mapChangeRequests.Last();
candidateOriginalBeatmap = await Task.Run(() => LoadBeatmap(mapChangeRequests.Last().Name));
if (candidateOriginalBeatmap != null)
{
candidateNewBeatmap = new Beatmap(candidateOriginalBeatmap);
}
// if a new request came in, invalidate candidate beatmap and service the new request
}
// no new requests, we can commit to using this beatmap
OriginalBeatmap = candidateOriginalBeatmap;
NewBeatmap = candidateNewBeatmap;
if (OriginalBeatmap == null)
{
SetState(EditorState.NOT_READY);
NotReadyReason = BadBeatmapReason.ERROR_LOADING_BEATMAP;
BeatmapSwitched?.Invoke(this, EventArgs.Empty);
}
else
{
if (OriginalBeatmap.HitObjectCount == 0)
{
SetState(EditorState.NOT_READY);
NotReadyReason = BadBeatmapReason.EMPTY_MAP;
BeatmapSwitched?.Invoke(this, EventArgs.Empty);
}
else
{
// Apply multiplier
if (BpmIsLocked)
{
SetBpm(lockedBpm);
}
NewBeatmap.SetRate(BpmRate);
// Apply bpm scaled settings
if (ScaleAR)
{
NewBeatmap.ApproachRate = DifficultyCalculator.CalculateMultipliedAR(candidateOriginalBeatmap, BpmRate);
}
if (ScaleOD)
{
NewBeatmap.OverallDifficulty = DifficultyCalculator.CalculateMultipliedOD(candidateOriginalBeatmap, BpmRate);
}
// Apply locked settings to new map
if (HpIsLocked)
{
NewBeatmap.HPDrainRate = lockedHP;
}
if (CsIsLocked)
{
NewBeatmap.CircleSize = lockedCS;
}
if (ArIsLocked)
{
NewBeatmap.ApproachRate = lockedAR;
}
if (OdIsLocked)
{
NewBeatmap.OverallDifficulty = lockedOD;
}
// Apply Hardrock
if (ForceHardrockCirclesize)
{
NewBeatmap.CircleSize = OriginalBeatmap.CircleSize * 1.3M;
}
SetState(EditorState.READY);
RequestDiffCalc();
BeatmapSwitched?.Invoke(this, EventArgs.Empty);
BeatmapModified?.Invoke(this, EventArgs.Empty);
}
}
ControlsModified?.Invoke(this, EventArgs.Empty);
serviceBeatmapRequestLocked = false;
}
public float GetScaledOD() => DifficultyCalculator.CalculateMultipliedOD(OriginalBeatmap, BpmMultiplier);
