private string Run_Program(MapCleanerVm args, BackgroundWorker worker, DoWorkEventArgs _)
{
var result = new Classes.Tools.MapCleaner.MapCleanerResult();
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
if (args.Paths.Length == 1)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(args.Paths[0], reader);
List <TimingPoint> orgininalTimingPoints = editor.Beatmap.BeatmapTiming.TimingPoints.Select(tp => tp.Copy()).ToList();
int oldTimingPointsCount = editor.Beatmap.BeatmapTiming.TimingPoints.Count;
result.Add(Classes.Tools.MapCleaner.CleanMap(editor, args.MapCleanerArgs, worker));
// Update result with removed count
int removed = oldTimingPointsCount - editor.Beatmap.BeatmapTiming.TimingPoints.Count;
result.TimingPointsRemoved += removed;
List <TimingPoint> newTimingPoints = editor.Beatmap.BeatmapTiming.TimingPoints;
Monitor_Differences(orgininalTimingPoints, newTimingPoints);
// Save the file
editor.SaveFile();
}
else
{
foreach (string path in args.Paths)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader);
int oldTimingPointsCount = editor.Beatmap.BeatmapTiming.TimingPoints.Count;
result.Add(Classes.Tools.MapCleaner.CleanMap(editor, args.MapCleanerArgs, worker));
// Update result with removed count
int removed = oldTimingPointsCount - editor.Beatmap.BeatmapTiming.TimingPoints.Count;
result.TimingPointsRemoved += removed;
// Save the file
editor.SaveFile();
}
}
// Do stuff
if (args.Quick)
{
RunFinished?.Invoke(this, new RunToolCompletedEventArgs(true, reader != null));
}
// Make an accurate message
string message = $"Successfully {(result.TimingPointsRemoved < 0 ? "added" : "removed")} {Math.Abs(result.TimingPointsRemoved)} {(Math.Abs(result.TimingPointsRemoved) == 1 ? "greenline" : "greenlines")}" +
(args.MapCleanerArgs.ResnapObjects ? $" and resnapped {result.ObjectsResnapped} {(result.ObjectsResnapped == 1 ? "object" : "objects")}" : "") +
(args.MapCleanerArgs.RemoveUnusedSamples ? $" and removed {result.SamplesRemoved} unused {(result.SamplesRemoved == 1 ? "sample" : "samples")}" : "") + "!";
return(args.Quick ? string.Empty : message);
}
private string PlaceHitsounds(Arguments args, BackgroundWorker worker, DoWorkEventArgs _)
{
if (args.Zones.Count == 0)
{
return("There are no zones!");
}
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
foreach (string path in args.Paths)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader);
Beatmap beatmap = editor.Beatmap;
Timeline timeline = beatmap.GetTimeline();
for (int i = 0; i < timeline.TimelineObjects.Count; i++)
{
var tlo = timeline.TimelineObjects[i];
var column = args.Zones.FirstOrDefault();
double best = double.MaxValue;
foreach (var c in args.Zones)
{
double dist = c.Distance(tlo.Origin.Pos);
if (dist < best)
{
best = dist;
column = c;
}
}
if (column == null)
{
continue;
}
tlo.Filename = column.Filename;
tlo.SampleSet = column.SampleSet;
tlo.AdditionSet = column.AdditionsSet;
tlo.CustomIndex = column.CustomIndex;
tlo.SampleVolume = 0;
tlo.SetHitsound(column.Hitsound);
tlo.HitsoundsToOrigin();
UpdateProgressBar(worker, (int)(100f * i / beatmap.HitObjects.Count));
}
// Save the file
editor.SaveFile();
}
// Do stuff
RunFinished?.Invoke(this, new RunToolCompletedEventArgs(true, reader != null, args.Quick));
return(args.Quick ? "" : "Done!");
}
public static List <HitsoundLayer> ImportStoryboard(string path, bool volumes, bool removeDuplicates)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(path);
Beatmap beatmap = editor.Beatmap;
string mapDir = editor.GetParentFolder();
var hitsoundLayers = ImportStoryboard(path, volumes, removeDuplicates, beatmap, mapDir);
return(hitsoundLayers);
}
/// <summary>
/// Generates a temp file with the newest version of specified map and returns the path to that temp file.
/// </summary>
/// <param name="mapPath"></param>
/// <returns></returns>
private static string GetNewestVersionPath(string mapPath)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(mapPath);
// Save temp version
var tempPath = Path.Combine(MainWindow.AppDataPath, "temp.osu");
Editor.SaveFile(tempPath, editor.Beatmap.GetLines());
return(tempPath);
}
private void PeriodicBackupTimerOnTick(object sender, EventArgs e)
{
try {
// Get the newest beatmap, save a temp version, get the hash and compare it to the previous hash, backup temp file
var path = IOHelper.GetCurrentBeatmap();
if (string.IsNullOrEmpty(path))
{
return;
}
// Don't make period backup if the editor is not open
if (!EditorReaderStuff.IsEditorOpen())
{
return;
}
EditorReader reader = null;
try {
reader = EditorReaderStuff.GetFullEditorReader();
} catch (Exception ex) {
Console.WriteLine(ex.MessageStackTrace());
}
var editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader);
// Save temp version
var tempPath = Path.Combine(MainWindow.AppDataPath, "temp.osu");
Editor.SaveFile(tempPath, editor.Beatmap.GetLines());
// Get MD5 from temp file
var currentMapHash = EditorReaderStuff.GetMD5FromPath(tempPath);
// Comparing with previously made periodic backup
if (currentMapHash == previousPeriodicBackupHash)
{
return;
}
// Saving backup of the map
BackupManager.SaveMapBackup(tempPath, true, Path.GetFileName(path), "PB"); // PB stands for Periodic Backup
previousPeriodicBackupHash = currentMapHash;
} catch (Exception ex) {
Console.WriteLine(ex.Message);
}
}
public static List <double> TimesFromStack(string path, double x, double y)
{
List <double> times = new List <double>();
var editor = EditorReaderStuff.GetNewestVersionOrNot(path);
bool xIgnore = x == -1;
bool yIgnore = y == -1;
foreach (HitObject ho in editor.Beatmap.HitObjects)
{
if ((Math.Abs(ho.Pos.X - x) < 3 || xIgnore) && (Math.Abs(ho.Pos.Y - y) < 3 || yIgnore))
{
times.Add(ho.Time);
}
}
return(times);
}
private static string Copy_Metadata(MetadataManagerVm arg, BackgroundWorker worker, DoWorkEventArgs _)
{
var paths = arg.ExportPath.Split('|');
var mapsDone = 0;
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
foreach (var path in paths)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader);
var beatmap = editor.Beatmap;
beatmap.Metadata["ArtistUnicode"].Value = arg.Artist;
beatmap.Metadata["Artist"].Value = arg.RomanisedArtist;
beatmap.Metadata["TitleUnicode"].Value = arg.Title;
beatmap.Metadata["Title"].Value = arg.RomanisedTitle;
beatmap.Metadata["Creator"].Value = arg.BeatmapCreator;
beatmap.Metadata["Source"].Value = arg.Source;
beatmap.Metadata["Tags"].Value = arg.Tags;
beatmap.General["PreviewTime"] = new TValue(arg.PreviewTime.ToRoundInvariant());
if (arg.UseComboColours)
{
beatmap.ComboColours = new List <ComboColour>(arg.ComboColours);
beatmap.SpecialColours.Clear();
foreach (var specialColour in arg.SpecialColours)
{
beatmap.SpecialColours.Add(specialColour.Name, specialColour);
}
}
// Save the file with name update because we updated the metadata
editor.SaveFileWithNameUpdate();
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(++mapsDone * 100 / paths.Length);
}
}
// Make an accurate message
var message = $"Successfully exported metadata to {mapsDone} {(mapsDone == 1 ? "beatmap" : "beatmaps")}!";
return(message);
}
private string ExportPattern(PatternGalleryVm args, BackgroundWorker worker, DoWorkEventArgs _)
{
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
var editor = EditorReaderStuff.GetNewestVersionOrNot(IOHelper.GetCurrentBeatmapOrCurrentBeatmap(), reader);
var pattern = args.Patterns.FirstOrDefault(o => o.IsSelected);
if (pattern == null)
{
throw new Exception("No pattern has been selected to export.");
}
var patternBeatmap = pattern.GetPatternBeatmap(args.FileHandler);
var patternPlacer = args.OsuPatternPlacer;
if (reader != null)
{
patternPlacer.PlaceOsuPatternAtTime(patternBeatmap, editor.Beatmap, reader.EditorTime(), false);
}
else
{
patternPlacer.PlaceOsuPattern(patternBeatmap, editor.Beatmap, protectBeatmapPattern: false);
}
editor.SaveFile();
// Increase pattern use count and time
pattern.UseCount++;
pattern.LastUsedTime = DateTime.Now;
// Complete progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(100);
}
// Do stuff
if (args.Quick)
{
RunFinished?.Invoke(this, new RunToolCompletedEventArgs(true, reader != null));
}
return("Successfully exported pattern!");
}
private string Complete_Sliders(SliderCompletionatorVm arg, BackgroundWorker worker, DoWorkEventArgs _)
{
int slidersCompleted = 0;
var reader = EditorReaderStuff.GetFullEditorReaderOrNot(out var editorReaderException1);
if (arg.ImportModeSetting == SliderCompletionatorVm.ImportMode.Selected && editorReaderException1 != null)
{
throw new Exception("Could not fetch selected hit objects.", editorReaderException1);
}
foreach (string path in arg.Paths)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader, out var selected, out var editorReaderException2);
if (arg.ImportModeSetting == SliderCompletionatorVm.ImportMode.Selected && editorReaderException2 != null)
{
throw new Exception("Could not fetch selected hit objects.", editorReaderException2);
}
Beatmap beatmap = editor.Beatmap;
Timing timing = beatmap.BeatmapTiming;
List <HitObject> markedObjects = arg.ImportModeSetting switch {
SliderCompletionatorVm.ImportMode.Selected => selected,
SliderCompletionatorVm.ImportMode.Bookmarked => beatmap.GetBookmarkedObjects(),
SliderCompletionatorVm.ImportMode.Time => beatmap.QueryTimeCode(arg.TimeCode).ToList(),
SliderCompletionatorVm.ImportMode.Everything => beatmap.HitObjects,
_ => throw new ArgumentException("Unexpected import mode.")
};
for (int i = 0; i < markedObjects.Count; i++)
{
HitObject ho = markedObjects[i];
if (ho.IsSlider)
{
double mpb = timing.GetMpBAtTime(ho.Time);
double oldDuration = timing.CalculateSliderTemporalLength(ho.Time, ho.PixelLength);
double oldLength = ho.PixelLength;
double oldSv = timing.GetSvAtTime(ho.Time);
double newDuration = arg.UseEndTime ? arg.EndTime == -1 ? oldDuration : arg.EndTime - ho.Time :
arg.Duration == -1 ? oldDuration : timing.WalkBeatsInMillisecondTime(arg.Duration, ho.Time) - ho.Time;
double newLength = arg.Length == -1 ? oldLength : ho.GetSliderPath(fullLength: true).Distance *arg.Length;
double newSv = arg.SliderVelocity == -1 ? oldSv : -100 / arg.SliderVelocity;
switch (arg.FreeVariableSetting)
{
case SliderCompletionatorVm.FreeVariable.Velocity:
newSv = -10000 * timing.SliderMultiplier * newDuration / (newLength * mpb);
break;
case SliderCompletionatorVm.FreeVariable.Duration:
// This actually doesn't get used anymore because the .osu doesn't store the duration
newDuration = newLength * newSv * mpb / (-10000 * timing.SliderMultiplier);
break;
case SliderCompletionatorVm.FreeVariable.Length:
newLength = -10000 * timing.SliderMultiplier * newDuration / (newSv * mpb);
break;
default:
throw new ArgumentException("Unexpected free variable setting.");
}
if (double.IsNaN(newSv))
{
throw new Exception("Encountered NaN slider velocity. Make sure none of the inputs are zero.");
}
if (newDuration < 0)
{
throw new Exception("Encountered slider with negative duration. Make sure the end time is greater than the end time of all selected sliders.");
}
ho.SliderVelocity = newSv;
ho.PixelLength = newLength;
// Scale anchors to completion
if (arg.MoveAnchors)
{
ho.SetAllCurvePoints(SliderPathUtil.MoveAnchorsToLength(
ho.GetAllCurvePoints(), ho.SliderType, ho.PixelLength, out var pathType));
ho.SliderType = pathType;
}
slidersCompleted++;
}
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(i / markedObjects.Count);
}
}
// Reconstruct SliderVelocity
List <TimingPointsChange> timingPointsChanges = new List <TimingPointsChange>();
// Add Hitobject stuff
foreach (HitObject ho in beatmap.HitObjects)
{
// SliderVelocity changes
if (ho.IsSlider)
{
if (markedObjects.Contains(ho) && arg.DelegateToBpm)
{
var tpAfter = timing.GetRedlineAtTime(ho.Time).Copy();
var tpOn = tpAfter.Copy();
tpAfter.Offset = ho.Time;
tpOn.Offset = ho.Time - 1; // This one will be on the slider
tpAfter.OmitFirstBarLine = true;
tpOn.OmitFirstBarLine = true;
// Express velocity in BPM
tpOn.MpB *= ho.SliderVelocity / -100;
// NaN SV results in removal of slider ticks
ho.SliderVelocity = arg.RemoveSliderTicks ? double.NaN : -100;
// Add redlines
timingPointsChanges.Add(new TimingPointsChange(tpOn, mpb: true, unInherited: true, omitFirstBarLine: true, fuzzyness: Precision.DOUBLE_EPSILON));
timingPointsChanges.Add(new TimingPointsChange(tpAfter, mpb: true, unInherited: true, omitFirstBarLine: true, fuzzyness: Precision.DOUBLE_EPSILON));
ho.Time -= 1;
}
TimingPoint tp = ho.TimingPoint.Copy();
tp.Offset = ho.Time;
tp.MpB = ho.SliderVelocity;
timingPointsChanges.Add(new TimingPointsChange(tp, mpb: true, fuzzyness: Precision.DOUBLE_EPSILON));
}
}
// Add the new SliderVelocity changes
TimingPointsChange.ApplyChanges(timing, timingPointsChanges);
// Save the file
editor.SaveFile();
}
// Complete progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(100);
}
// Do stuff
RunFinished?.Invoke(this, new RunToolCompletedEventArgs(true, reader != null, arg.Quick));
// Make an accurate message
string message = "";
if (Math.Abs(slidersCompleted) == 1)
{
message += "Successfully completed " + slidersCompleted + " slider!";
}
else
{
message += "Successfully completed " + slidersCompleted + " sliders!";
}
return(arg.Quick ? "" : message);
}
private string Complete_Sliders(SliderCompletionatorVm arg, BackgroundWorker worker, DoWorkEventArgs _)
{
int slidersCompleted = 0;
var reader = EditorReaderStuff.GetFullEditorReaderOrNot(out var editorReaderException1);
if (arg.ImportModeSetting == SliderCompletionatorVm.ImportMode.Selected && editorReaderException1 != null)
{
throw new Exception("Could not fetch selected hit objects.", editorReaderException1);
}
foreach (string path in arg.Paths)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader, out var selected, out var editorReaderException2);
if (arg.ImportModeSetting == SliderCompletionatorVm.ImportMode.Selected && editorReaderException2 != null)
{
throw new Exception("Could not fetch selected hit objects.", editorReaderException2);
}
Beatmap beatmap = editor.Beatmap;
Timing timing = beatmap.BeatmapTiming;
List <HitObject> markedObjects = arg.ImportModeSetting == SliderCompletionatorVm.ImportMode.Selected ? selected :
arg.ImportModeSetting == SliderCompletionatorVm.ImportMode.Bookmarked ? beatmap.GetBookmarkedObjects() :
arg.ImportModeSetting == SliderCompletionatorVm.ImportMode.Time ? beatmap.QueryTimeCode(arg.TimeCode).ToList() :
beatmap.HitObjects;
for (int i = 0; i < markedObjects.Count; i++)
{
HitObject ho = markedObjects[i];
if (ho.IsSlider)
{
double oldSpatialLength = ho.PixelLength;
double newSpatialLength = arg.SpatialLength != -1 ? ho.GetSliderPath(fullLength: true).Distance *arg.SpatialLength : oldSpatialLength;
double oldTemporalLength = timing.CalculateSliderTemporalLength(ho.Time, ho.PixelLength);
double newTemporalLength = arg.TemporalLength != -1 ? timing.GetMpBAtTime(ho.Time) * arg.TemporalLength : oldTemporalLength;
double oldSv = timing.GetSvAtTime(ho.Time);
double newSv = oldSv / ((newSpatialLength / oldSpatialLength) / (newTemporalLength / oldTemporalLength));
if (double.IsNaN(newSv))
{
throw new Exception("Encountered NaN slider velocity. Make sure none of the inputs are zero.");
}
ho.SliderVelocity = newSv;
ho.PixelLength = newSpatialLength;
// Scale anchors to completion
if (arg.MoveAnchors)
{
ho.SetAllCurvePoints(SliderPathUtil.MoveAnchorsToLength(
ho.GetAllCurvePoints(), ho.SliderType, ho.PixelLength, out var pathType));
ho.SliderType = pathType;
}
slidersCompleted++;
}
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(i / markedObjects.Count);
}
}
// Reconstruct SliderVelocity
List <TimingPointsChange> timingPointsChanges = new List <TimingPointsChange>();
// Add Hitobject stuff
foreach (HitObject ho in beatmap.HitObjects)
{
if (ho.IsSlider) // SliderVelocity changes
{
TimingPoint tp = ho.TimingPoint.Copy();
tp.Offset = ho.Time;
tp.MpB = ho.SliderVelocity;
timingPointsChanges.Add(new TimingPointsChange(tp, mpb: true));
}
}
// Add the new SliderVelocity changes
TimingPointsChange.ApplyChanges(timing, timingPointsChanges);
// Save the file
editor.SaveFile();
}
// Complete progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(100);
}
// Do stuff
if (arg.Quick)
{
RunFinished?.Invoke(this, new RunToolCompletedEventArgs(true, reader != null));
}
// Make an accurate message
string message = "";
if (Math.Abs(slidersCompleted) == 1)
{
message += "Successfully completed " + slidersCompleted + " slider!";
}
else
{
message += "Successfully completed " + slidersCompleted + " sliders!";
}
return(arg.Quick ? "" : message);
}
/// <summary>
/// Extract every used sample in a beatmap and return them as hitsound layers.
/// </summary>
/// <param name="path">The path to the beatmap.</param>
/// <param name="volumes">Taking the volumes from the map and making different layers for different volumes.</param>
/// <param name="detectDuplicateSamples">Detect duplicate samples and optimise hitsound layer count with that.</param>
/// <param name="removeDuplicates">Removes duplicate sounds at the same millisecond.</param>
/// <param name="includeStoryboard">Also imports storyboarded samples.</param>
/// <returns>The hitsound layers</returns>
public static List <HitsoundLayer> ImportHitsounds(string path, bool volumes, bool detectDuplicateSamples, bool removeDuplicates, bool includeStoryboard)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(path);
Beatmap beatmap = editor.Beatmap;
Timeline timeline = beatmap.GetTimeline();
GameMode mode = (GameMode)beatmap.General["Mode"].IntValue;
string mapDir = editor.GetParentFolder();
Dictionary <string, string> firstSamples = AnalyzeSamples(mapDir, false, detectDuplicateSamples);
List <HitsoundLayer> hitsoundLayers = new List <HitsoundLayer>();
foreach (TimelineObject tlo in timeline.TimelineObjects)
{
if (!tlo.HasHitsound)
{
continue;
}
double volume = volumes ? tlo.FenoSampleVolume / 100 : 1;
List <string> samples = tlo.GetPlayingFilenames(mode);
foreach (string filename in samples)
{
bool isFilename = tlo.UsesFilename;
SampleSet sampleSet = isFilename ? tlo.FenoSampleSet : GetSamplesetFromFilename(filename);
Hitsound hitsound = isFilename ? tlo.GetHitsound() : GetHitsoundFromFilename(filename);
string samplePath = Path.Combine(mapDir, filename);
string fullPathExtLess = Path.Combine(
Path.GetDirectoryName(samplePath) ?? throw new InvalidOperationException(),
Path.GetFileNameWithoutExtension(samplePath));
// Get the first occurence of this sound to not get duplicated
if (firstSamples.Keys.Contains(fullPathExtLess))
{
samplePath = firstSamples[fullPathExtLess];
}
else
{
// Sample doesn't exist
if (!isFilename)
{
samplePath = Path.Combine(
Path.GetDirectoryName(samplePath) ?? throw new InvalidOperationException(),
$"{sampleSet.ToString().ToLower()}-hit{hitsound.ToString().ToLower()}-1.wav");
}
}
string extLessFilename = Path.GetFileNameWithoutExtension(samplePath);
var importArgs = new LayerImportArgs(ImportType.Hitsounds)
{
Path = path, SamplePath = samplePath,
Volume = volume, DetectDuplicateSamples = detectDuplicateSamples, DiscriminateVolumes = volumes, RemoveDuplicates = removeDuplicates
};
// Find the hitsoundlayer with this path
HitsoundLayer layer = hitsoundLayers.Find(o => o.ImportArgs == importArgs);
if (layer != null)
{
// Find hitsound layer with this path and add this time
layer.Times.Add(tlo.Time);
}
else
{
// Add new hitsound layer with this path
HitsoundLayer newLayer = new HitsoundLayer(extLessFilename,
sampleSet,
hitsound,
new SampleGeneratingArgs(samplePath)
{
Volume = volume
},
importArgs);
newLayer.Times.Add(tlo.Time);
hitsoundLayers.Add(newLayer);
}
}
}
if (includeStoryboard)
{
hitsoundLayers.AddRange(ImportStoryboard(path, volumes, removeDuplicates, beatmap, mapDir, "SB: "));
}
// Sort layers by name
hitsoundLayers = hitsoundLayers.OrderBy(o => o.Name).ToList();
if (removeDuplicates)
{
foreach (var hitsoundLayer in hitsoundLayers)
{
hitsoundLayer.Times.Sort();
hitsoundLayer.RemoveDuplicates();
}
}
return(hitsoundLayers);
}
private string Adjust_Timing(Arguments arg, BackgroundWorker worker, DoWorkEventArgs _)
{
// Count
int RedlinesAdded = 0;
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
foreach (string path in arg.Paths)
{
// Open beatmap
var editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader);
Beatmap beatmap = editor.Beatmap;
Timing timing = beatmap.BeatmapTiming;
// Get all the times to snap
List <Marker> markers = new List <Marker>();
if (arg.Objects)
{
foreach (HitObject ho in beatmap.HitObjects)
{
markers.Add(new Marker(ho.Time));
}
}
if (arg.Bookmarks)
{
foreach (double time in beatmap.GetBookmarks())
{
markers.Add(new Marker(time));
}
}
if (arg.Greenlines)
{
// Get the offsets of greenlines
foreach (TimingPoint tp in timing.TimingPoints)
{
if (tp.Uninherited == false)
{
markers.Add(new Marker(tp.Offset));
}
}
}
if (arg.Redlines)
{
// Get the offsets of redlines
foreach (TimingPoint tp in timing.TimingPoints)
{
if (tp.Uninherited == true)
{
markers.Add(new Marker(tp.Offset));
}
}
}
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(20);
}
// Sort the markers
markers = markers.OrderBy(o => o.Time).ToList();
// Calculate the beats between time and the last time or redline for each time
// Time the same is 0
// Time a little after is smallest snap
for (int i = 0; i < markers.Count; i++)
{
Marker marker = markers[i];
double time = marker.Time;
TimingPoint redline = timing.GetRedlineAtTime(time - 1);
// Resnap to that redline only
double resnappedTime = timing.Resnap(time, arg.BeatDivisors, false, tp: redline);
// Calculate beats from the redline
double beatsFromRedline = (resnappedTime - redline.Offset) / redline.MpB;
// Avoid problems
if (MathHelper.ApproximatelyEquivalent(beatsFromRedline, 0, 0.0001))
{
beatsFromRedline = arg.BeatDivisors.Max(o => o.GetValue());
}
if (time == redline.Offset)
{
beatsFromRedline = 0;
}
// Initialize the beats from last marker
double beatsFromLastMarker = beatsFromRedline;
// Get the times between redline and this time
List <Marker> timesBefore = markers.Where(o => o.Time <time && o.Time> redline.Offset).ToList();
if (timesBefore.Count > 0)
{
// Get the last time info
double lastTime = timesBefore.Last().Time;
double resnappedTimeL = timing.Resnap(lastTime, arg.BeatDivisors, false);
// Change the beats from last marker
beatsFromLastMarker = (resnappedTime - resnappedTimeL) / redline.MpB;
// Avoid problems
if (MathHelper.ApproximatelyEquivalent(beatsFromLastMarker, 0, 0.0001))
{
beatsFromLastMarker = arg.BeatDivisors.Max(o => o.GetValue());
}
if (lastTime == time)
{
beatsFromLastMarker = 0;
}
}
// Set the variable
marker.BeatsFromLastMarker = beatsFromLastMarker;
}
// Remove redlines except the first redline
if (!arg.Redlines)
{
var first = timing.TimingPoints.FirstOrDefault(o => o.Uninherited);
timing.RemoveAll(o => o.Uninherited && o != first);
}
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(40);
}
// Loop through all the markers
for (int i = 0; i < markers.Count; i++)
{
Marker marker = markers[i];
double time = marker.Time;
TimingPoint redline = timing.GetRedlineAtTime(time - 1);
double beatsFromLastMarker = arg.BeatsBetween != -1 ? arg.BeatsBetween : marker.BeatsFromLastMarker;
// Skip if 0 beats from last marker
if (beatsFromLastMarker == 0)
{
continue;
}
// Get the times between redline and this time including this time
List <Marker> markersBefore = markers.Where(o => o.Time <time && o.Time> redline.Offset).ToList();
markersBefore.Add(marker);
// Calculate MpB
// Average MpB from timesBefore and use time from redline
double mpb = 0;
double beatsFromRedline = 0;
foreach (Marker markerB in markersBefore)
{
beatsFromRedline += markerB.BeatsFromLastMarker;
mpb += GetMpB(markerB.Time - redline.Offset, beatsFromRedline, 0);
}
mpb /= markersBefore.Count;
// Check if this MpB doesn't make the markers go offsnap too far
bool canChangeRedline = CheckMpB(mpb, markersBefore, redline, arg);
// Make changes
if (canChangeRedline)
{
// Round the MpB to human values first
mpb = HumanRoundMpB(mpb, markersBefore, redline, arg);
// Change the MpB of the redline
redline.MpB = mpb;
}
else
{
// Get the last time info and not the current
markersBefore.Remove(marker);
double lastTime = markersBefore.Last().Time;
// Make new redline
TimingPoint newRedline = redline.Copy();
TimingPoint lastHitsounds = timing.GetTimingPointAtTime(lastTime + 5);
newRedline.Offset = lastTime;
newRedline.OmitFirstBarLine = arg.OmitBarline; // Set omit to the argument
newRedline.Kiai = lastHitsounds.Kiai;
newRedline.SampleIndex = lastHitsounds.SampleIndex;
newRedline.SampleSet = lastHitsounds.SampleSet;
newRedline.Volume = lastHitsounds.Volume;
timing.Add(newRedline);
// Set the MpB
newRedline.MpB = GetMpB(time - lastTime, beatsFromLastMarker, arg.Leniency);
// Update the counter
RedlinesAdded++;
}
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(i * 60 / markers.Count + 40);
}
}
// Save the file
editor.SaveFile();
}
// Complete progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(100);
}
// Make an accurate message
string message = "Successfully added ";
message += RedlinesAdded;
if (Math.Abs(RedlinesAdded) == 1)
{
message += " redlines!";
}
else
{
message += " redlines!";
}
return(message);
}
private static string Export_ComboColours(ComboColourStudioVm arg, BackgroundWorker worker, DoWorkEventArgs _)
{
var paths = arg.ExportPath.Split('|');
var mapsDone = 0;
var orderedColourPoints = arg.Project.ColourPoints.OrderBy(o => o.Time).ToList();
var orderedComboColours = arg.Project.ComboColours.OrderBy(o => o.Name).ToList();
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
foreach (var path in paths)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader);
var beatmap = editor.Beatmap;
// Setting the combo colours
beatmap.ComboColours = new List <ComboColour>(arg.Project.ComboColours);
// Setting the combo skips
if (beatmap.HitObjects.Count > 0 && orderedColourPoints.Count > 0)
{
int lastColourPointColourIndex = -1;
var lastColourPoint = orderedColourPoints[0];
int lastColourIndex = 0;
var exceptions = new List <ColourPoint>();
foreach (var newCombo in beatmap.HitObjects.Where(o => o.ActualNewCombo && !o.IsSpinner))
{
int comboLength = GetComboLength(newCombo, beatmap.HitObjects);
//Console.WriteLine(comboLength);
// Get the colour point for this new combo
var colourPoint = GetColourPoint(orderedColourPoints, newCombo.Time, exceptions, comboLength <= arg.Project.MaxBurstLength);
var colourSequence = colourPoint.ColourSequence.ToList();
// Add the colour point to the exceptions so it doesnt get used again
if (colourPoint.Mode == ColourPointMode.Burst)
{
exceptions.Add(colourPoint);
}
// Get the last colour index on the sequence of this colour point
lastColourPointColourIndex = lastColourPointColourIndex == -1 || lastColourPoint.Equals(colourPoint) ?
lastColourPointColourIndex :
colourSequence.FindIndex(o => o.Name == orderedComboColours[lastColourIndex].Name);
// Get the next colour index on this colour point
// Check if colourSequence count is 0 to prevent division by 0
var colourPointColourIndex = lastColourPointColourIndex == -1 || colourSequence.Count == 0
? 0
: lastColourPoint.Equals(colourPoint) ?
MathHelper.Mod(lastColourPointColourIndex + 1, colourSequence.Count) :
// If the colour point changed try going back to index 0
lastColourPointColourIndex == 0 && colourSequence.Count > 1 ? 1 : 0;
//Console.WriteLine("colourPointColourIndex: " + colourPointColourIndex);
//Console.WriteLine("colourPointColour: " + colourPoint.ColourSequence[colourPointColourIndex].Name);
// Find the combo index of the chosen colour in the sequence
// Check if the colourSequence count is 0 to prevent an out-of-range exception
var colourIndex = colourSequence.Count == 0 ? MathHelper.Mod(lastColourIndex + 1, orderedComboColours.Count) :
orderedComboColours.FindIndex(o => o.Name == colourSequence[colourPointColourIndex].Name);
if (colourIndex == -1)
{
throw new ArgumentException($"Can not use colour {colourSequence[colourPointColourIndex].Name} of colour point at offset {colourPoint.Time} because it does not exist in the combo colours.");
}
//Console.WriteLine("colourIndex: " + colourIndex);
var comboIncrease = MathHelper.Mod(colourIndex - lastColourIndex, arg.Project.ComboColours.Count);
// Do -1 combo skip since it always does +1 combo colour for each new combo which is not on a spinner
newCombo.ComboSkip = MathHelper.Mod(comboIncrease - 1, arg.Project.ComboColours.Count);
// Set new combo to true for the case this is the first object and new combo is false
if (!newCombo.NewCombo && newCombo.ComboSkip != 0)
{
newCombo.NewCombo = true;
}
//Console.WriteLine("comboSkip: " + newCombo.ComboSkip);
lastColourPointColourIndex = colourPointColourIndex;
lastColourPoint = colourPoint;
lastColourIndex = colourIndex;
}
}
// Save the file
editor.SaveFile();
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(++mapsDone * 100 / paths.Length);
}
}
// Make an accurate message
var message = $"Successfully exported colours to {mapsDone} {(mapsDone == 1 ? "beatmap" : "beatmaps")}!";
return(message);
}
private string Run_Program(AutoFailDetectorVm args, BackgroundWorker worker, DoWorkEventArgs _)
{
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
var editor = EditorReaderStuff.GetNewestVersionOrNot(args.Paths[0], reader);
var beatmap = editor.Beatmap;
// Get approach time and radius of the 50 score hit window
var ar = args.ApproachRateOverride == -1
? editor.Beatmap.Difficulty["ApproachRate"].DoubleValue
: args.ApproachRateOverride;
var approachTime = (int)Beatmap.GetApproachTime(ar);
var od = args.OverallDifficultyOverride == -1
? editor.Beatmap.Difficulty["OverallDifficulty"].DoubleValue
: args.OverallDifficultyOverride;
var window50 = (int)Math.Ceiling(200 - 10 * od);
// Start time and end time
var mapStartTime = (int)beatmap.GetMapStartTime();
var mapEndTime = (int)beatmap.GetMapEndTime();
var autoFailTime = (int)beatmap.GetAutoFailCheckTime();
// Detect auto-fail
var autoFailDetector = new Classes.Tools.AutoFailDetector(beatmap.HitObjects,
mapStartTime, mapEndTime, autoFailTime,
approachTime, window50, args.PhysicsUpdateLeniency);
var autoFail = autoFailDetector.DetectAutoFail();
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(33);
}
// Fix auto-fail
if (args.GetAutoFailFix)
{
var placedFix = autoFailDetector.AutoFailFixDialogue(args.AutoPlaceFix);
if (placedFix)
{
editor.SaveFile();
}
}
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(67);
}
// Set the timeline lists
_unloadingObjects = args.ShowUnloadingObjects ? autoFailDetector.UnloadingObjects : new List <double>();
_potentialUnloadingObjects = args.ShowPotentialUnloadingObjects ? autoFailDetector.PotentialUnloadingObjects : new List <double>();
_potentialDisruptors = args.ShowPotentialDisruptors ? autoFailDetector.Disruptors : new List <double>();
// Set end time for the timeline
_endTimeMonitor = mapEndTime;
// Complete progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(100);
}
// Do stuff
RunFinished?.Invoke(this, new RunToolCompletedEventArgs(true, false, args.Quick));
return(autoFail ? $"{autoFailDetector.UnloadingObjects.Count} unloading objects detected and {autoFailDetector.PotentialUnloadingObjects.Count} potential unloading objects detected!" :
autoFailDetector.PotentialUnloadingObjects.Count > 0 ? $"No auto-fail, but {autoFailDetector.PotentialUnloadingObjects.Count} potential unloading objects detected." :
"No auto-fail detected.");
}
public static void ExportHitsounds(List <HitsoundEvent> hitsounds, string baseBeatmap, string exportFolder, string exportMapName, GameMode exportGameMode, bool useGreenlines, bool useStoryboard)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(baseBeatmap);
Beatmap beatmap = editor.Beatmap;
if (useStoryboard)
{
beatmap.StoryboardSoundSamples.Clear();
foreach (var h in hitsounds.Where(h => !string.IsNullOrEmpty(h.Filename)))
{
beatmap.StoryboardSoundSamples.Add(new StoryboardSoundSample(h.Time, 0, h.Filename, h.Volume * 100));
}
}
else
{
// Make new timing points
// Add red lines
List <TimingPoint> timingPoints = beatmap.BeatmapTiming.GetAllRedlines();
List <TimingPointsChange> timingPointsChanges = timingPoints.Select(tp =>
new TimingPointsChange(tp, mpb: true, meter: true, inherited: true, omitFirstBarLine: true))
.ToList();
// Add hitsound stuff
// Replace all hitobjects with the hitsounds
beatmap.HitObjects.Clear();
foreach (HitsoundEvent h in hitsounds)
{
if (useGreenlines)
{
TimingPoint tp = beatmap.BeatmapTiming.GetTimingPointAtTime(h.Time + 5).Copy();
tp.Offset = h.Time;
tp.SampleIndex = h.CustomIndex;
h.CustomIndex = 0; // Set it to default value because it gets handled by greenlines now
tp.Volume = Math.Round(tp.Volume * h.Volume);
h.Volume = 0; // Set it to default value because it gets handled by greenlines now
timingPointsChanges.Add(new TimingPointsChange(tp, index: true, volume: true));
}
beatmap.HitObjects.Add(new HitObject(h.Pos, h.Time, 5, h.GetHitsounds(), h.SampleSet, h.Additions,
h.CustomIndex, h.Volume * 100, h.Filename));
}
// Replace the old timingpoints
beatmap.BeatmapTiming.TimingPoints.Clear();
TimingPointsChange.ApplyChanges(beatmap.BeatmapTiming, timingPointsChanges);
}
// Change version to hitsounds
beatmap.General["StackLeniency"] = new TValue("0.0");
beatmap.General["Mode"] = new TValue(((int)exportGameMode).ToInvariant());
beatmap.Metadata["Version"] = new TValue(exportMapName);
if (exportGameMode == GameMode.Mania)
{
// Count the number of distinct X positions
int numXPositions = new HashSet <double>(hitsounds.Select(h => h.Pos.X)).Count;
int numKeys = MathHelper.Clamp(numXPositions, 1, 18);
beatmap.Difficulty["CircleSize"] = new TValue(numKeys.ToInvariant());
}
else
{
beatmap.Difficulty["CircleSize"] = new TValue("4");
}
// Save the file to the export folder
editor.SaveFile(Path.Combine(exportFolder, beatmap.GetFileName()));
}
private string Merge_Sliders(SliderMergerVm arg, BackgroundWorker worker)
{
var slidersMerged = 0;
var reader = EditorReaderStuff.GetFullEditorReaderOrNot(out var editorReaderException1);
if (arg.ImportModeSetting == 0 && editorReaderException1 != null)
{
throw new Exception("Could not fetch selected hit objects.", editorReaderException1);
}
foreach (var path in arg.Paths)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader, out var selected, out var editorReaderException2);
if (arg.ImportModeSetting == SliderMergerVm.ImportMode.Selected && editorReaderException2 != null)
{
throw new Exception("Could not fetch selected hit objects.", editorReaderException2);
}
var beatmap = editor.Beatmap;
var markedObjects = arg.ImportModeSetting == 0 ? selected :
arg.ImportModeSetting == SliderMergerVm.ImportMode.Bookmarked ? beatmap.GetBookmarkedObjects() :
arg.ImportModeSetting == SliderMergerVm.ImportMode.Time ? beatmap.QueryTimeCode(arg.TimeCode).ToList() :
beatmap.HitObjects;
var mergeLast = false;
for (var i = 0; i < markedObjects.Count - 1; i++)
{
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(i / markedObjects.Count);
}
var ho1 = markedObjects[i];
var ho2 = markedObjects[i + 1];
var lastPos1 = ho1.IsSlider
? arg.MergeOnSliderEnd ? ho1.GetSliderPath().PositionAt(1) : ho1.CurvePoints.Last()
: ho1.Pos;
double dist = Vector2.Distance(lastPos1, ho2.Pos);
if (dist > arg.Leniency)
{
mergeLast = false;
continue;
}
if (ho1.IsSlider && ho2.IsSlider)
{
if (arg.MergeOnSliderEnd)
{
// In order to merge on the slider end we first move the anchors such that the last anchor is exactly on the slider end
// After that merge as usual
ho1.SetAllCurvePoints(SliderPathUtil.MoveAnchorsToLength(
ho1.GetAllCurvePoints(), ho1.SliderType, ho1.PixelLength, out var pathType));
ho1.SliderType = pathType;
}
var sp1 = BezierConverter.ConvertToBezier(ho1.SliderPath).ControlPoints;
var sp2 = BezierConverter.ConvertToBezier(ho2.SliderPath).ControlPoints;
double extraLength = 0;
switch (arg.ConnectionModeSetting)
{
case SliderMergerVm.ConnectionMode.Move:
Move(sp2, sp1.Last() - sp2.First());
break;
case SliderMergerVm.ConnectionMode.Linear:
sp1.Add(sp1.Last());
sp1.Add(sp2.First());
extraLength = (ho1.CurvePoints.Last() - ho2.Pos).Length;
break;
}
var mergedAnchors = sp1.Concat(sp2).ToList();
mergedAnchors.Round();
var linearLinear = arg.LinearOnLinear && IsLinearBezier(sp1) && IsLinearBezier(sp2);
if (linearLinear)
{
for (var j = 0; j < mergedAnchors.Count - 1; j++)
{
if (mergedAnchors[j] != mergedAnchors[j + 1])
{
continue;
}
mergedAnchors.RemoveAt(j);
j--;
}
}
var mergedPath = new SliderPath(linearLinear ? PathType.Linear : PathType.Bezier, mergedAnchors.ToArray(),
ho1.PixelLength + ho2.PixelLength + extraLength);
ho1.SliderPath = mergedPath;
beatmap.HitObjects.Remove(ho2);
markedObjects.Remove(ho2);
i--;
slidersMerged++;
if (!mergeLast)
{
slidersMerged++;
}
mergeLast = true;
}
else if (ho1.IsSlider && ho2.IsCircle)
{
var sp1 = BezierConverter.ConvertToBezier(ho1.SliderPath).ControlPoints;
sp1.Add(sp1.Last());
sp1.Add(ho2.Pos);
var extraLength = (ho1.CurvePoints.Last() - ho2.Pos).Length;
var mergedAnchors = sp1;
mergedAnchors.Round();
var linearLinear = arg.LinearOnLinear && IsLinearBezier(sp1);
if (linearLinear)
{
for (var j = 0; j < mergedAnchors.Count - 1; j++)
{
if (mergedAnchors[j] != mergedAnchors[j + 1])
{
continue;
}
mergedAnchors.RemoveAt(j);
j--;
}
}
var mergedPath = new SliderPath(linearLinear ? PathType.Linear : PathType.Bezier, mergedAnchors.ToArray(), ho1.PixelLength + extraLength);
ho1.SliderPath = mergedPath;
beatmap.HitObjects.Remove(ho2);
markedObjects.Remove(ho2);
i--;
slidersMerged++;
if (!mergeLast)
{
slidersMerged++;
}
mergeLast = true;
}
else if (ho1.IsCircle && ho2.IsSlider)
{
var sp2 = BezierConverter.ConvertToBezier(ho2.SliderPath).ControlPoints;
sp2.Insert(0, sp2.First());
sp2.Insert(0, ho1.Pos);
var extraLength = (ho1.Pos - ho2.Pos).Length;
var mergedAnchors = sp2;
mergedAnchors.Round();
var linearLinear = arg.LinearOnLinear && IsLinearBezier(sp2);
if (linearLinear)
{
for (var j = 0; j < mergedAnchors.Count - 1; j++)
{
if (mergedAnchors[j] != mergedAnchors[j + 1])
{
continue;
}
mergedAnchors.RemoveAt(j);
j--;
}
}
var mergedPath = new SliderPath(linearLinear ? PathType.Linear : PathType.Bezier, mergedAnchors.ToArray(), ho2.PixelLength + extraLength);
ho2.SliderPath = mergedPath;
beatmap.HitObjects.Remove(ho1);
markedObjects.Remove(ho1);
i--;
slidersMerged++;
if (!mergeLast)
{
slidersMerged++;
}
mergeLast = true;
}
else if (ho1.IsCircle && ho2.IsCircle)
{
var mergedAnchors = new List <Vector2> {
ho1.Pos, ho2.Pos
};
var mergedPath = new SliderPath(arg.LinearOnLinear ? PathType.Linear : PathType.Bezier, mergedAnchors.ToArray(), (ho1.Pos - ho2.Pos).Length);
ho1.SliderPath = mergedPath;
ho1.IsCircle = false;
ho1.IsSlider = true;
ho1.Repeat = 1;
ho1.EdgeHitsounds = new List <int> {
ho1.GetHitsounds(), ho2.GetHitsounds()
};
ho1.EdgeSampleSets = new List <SampleSet> {
ho1.SampleSet, ho2.SampleSet
};
ho1.EdgeAdditionSets = new List <SampleSet> {
ho1.AdditionSet, ho2.AdditionSet
};
beatmap.HitObjects.Remove(ho2);
markedObjects.Remove(ho2);
i--;
slidersMerged++;
if (!mergeLast)
{
slidersMerged++;
}
mergeLast = true;
}
else
{
mergeLast = false;
}
}
// Save the file
editor.SaveFile();
}
// Complete progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(100);
}
// Do stuff
if (arg.Quick)
{
RunFinished?.Invoke(this, new RunToolCompletedEventArgs(true, reader != null));
}
// Make an accurate message
var message = "";
if (Math.Abs(slidersMerged) == 1)
{
message += "Successfully merged " + slidersMerged + " slider!";
}
else
{
message += "Successfully merged " + slidersMerged + " sliders!";
}
return(arg.Quick ? "" : message);
}
private string TransformProperties(PropertyTransformerVm vm, BackgroundWorker worker, DoWorkEventArgs _)
{
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
foreach (string path in vm.ExportPaths)
{
Editor editor;
if (Path.GetExtension(path) == ".osb")
{
editor = new StoryboardEditor(path);
}
else
{
editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader);
}
if (editor is BeatmapEditor beatmapEditor)
{
Beatmap beatmap = beatmapEditor.Beatmap;
List <TimingPointsChange> timingPointsChanges = new List <TimingPointsChange>();
foreach (TimingPoint tp in beatmap.BeatmapTiming.TimingPoints)
{
// Offset
if (vm.TimingpointOffsetMultiplier != 1 || vm.TimingpointOffsetOffset != 0)
{
if (Filter(tp.Offset, tp.Offset, vm))
{
tp.Offset = Math.Round(tp.Offset * vm.TimingpointOffsetMultiplier +
vm.TimingpointOffsetOffset);
}
}
// BPM
if (vm.TimingpointBPMMultiplier != 1 || vm.TimingpointBPMOffset != 0)
{
if (tp.Uninherited)
{
if (Filter(tp.GetBpm(), tp.Offset, vm))
{
double newBPM = tp.GetBpm() * vm.TimingpointBPMMultiplier + vm.TimingpointBPMOffset;
newBPM = vm.ClipProperties
? MathHelper.Clamp(newBPM, 15, 10000)
: newBPM; // Clip the value if specified
tp.MpB = 60000 / newBPM;
}
}
}
// Slider Velocity
if (vm.TimingpointSVMultiplier != 1 || vm.TimingpointSVOffset != 0)
{
if (Filter(beatmap.BeatmapTiming.GetSvMultiplierAtTime(tp.Offset), tp.Offset, vm))
{
TimingPoint tpchanger = tp.Copy();
double newSV =
beatmap.BeatmapTiming.GetSvMultiplierAtTime(tp.Offset) *
vm.TimingpointSVMultiplier + vm.TimingpointSVOffset;
newSV = vm.ClipProperties
? MathHelper.Clamp(newSV, 0.1, 10)
: newSV; // Clip the value if specified
tpchanger.MpB = -100 / newSV;
timingPointsChanges.Add(new TimingPointsChange(tpchanger, mpb: true));
}
}
// Index
if (vm.TimingpointIndexMultiplier != 1 || vm.TimingpointIndexOffset != 0)
{
if (Filter(tp.SampleIndex, tp.Offset, vm))
{
int newIndex =
(int)Math.Round(tp.SampleIndex * vm.TimingpointIndexMultiplier +
vm.TimingpointIndexOffset);
tp.SampleIndex = vm.ClipProperties ? MathHelper.Clamp(newIndex, 0, int.MaxValue) : newIndex;
}
}
// Volume
if (vm.TimingpointVolumeMultiplier != 1 || vm.TimingpointVolumeOffset != 0)
{
if (Filter(tp.Volume, tp.Offset, vm))
{
int newVolume =
(int)Math.Round(tp.Volume * vm.TimingpointVolumeMultiplier +
vm.TimingpointVolumeOffset);
tp.Volume = vm.ClipProperties ? MathHelper.Clamp(newVolume, 5, 100) : newVolume;
}
}
}
UpdateProgressBar(worker, 20);
// Hitobject time
if (vm.HitObjectTimeMultiplier != 1 || vm.HitObjectTimeOffset != 0)
{
foreach (HitObject ho in beatmap.HitObjects)
{
// Get the end time early because the start time gets modified
double oldEndTime = ho.GetEndTime(false);
if (Filter(ho.Time, ho.Time, vm))
{
ho.Time = Math.Round(ho.Time * vm.HitObjectTimeMultiplier + vm.HitObjectTimeOffset);
}
// Transform end time of hold notes and spinner
if ((ho.IsHoldNote || ho.IsSpinner) &&
Filter(oldEndTime, oldEndTime, vm))
{
ho.EndTime = Math.Round(oldEndTime * vm.HitObjectTimeMultiplier + vm.HitObjectTimeOffset);
}
}
}
UpdateProgressBar(worker, 30);
// Bookmark time
if (vm.BookmarkTimeMultiplier != 1 || vm.BookmarkTimeOffset != 0)
{
List <double> newBookmarks = new List <double>();
List <double> bookmarks = beatmap.GetBookmarks();
foreach (double bookmark in bookmarks)
{
if (Filter(bookmark, bookmark, vm))
{
newBookmarks.Add(
Math.Round(bookmark * vm.BookmarkTimeMultiplier + vm.BookmarkTimeOffset));
}
else
{
newBookmarks.Add(bookmark);
}
}
beatmap.SetBookmarks(newBookmarks);
}
UpdateProgressBar(worker, 40);
// Storyboarded event time
if (vm.SBEventTimeMultiplier != 1 || vm.SBEventTimeOffset != 0)
{
foreach (Event ev in beatmap.StoryboardLayerBackground.Concat(beatmap.StoryboardLayerFail)
.Concat(beatmap.StoryboardLayerPass).Concat(beatmap.StoryboardLayerForeground)
.Concat(beatmap.StoryboardLayerOverlay))
{
TransformEventTime(ev, vm.SBEventTimeMultiplier, vm.SBEventTimeOffset, vm);
}
}
UpdateProgressBar(worker, 50);
// Storyboarded sample time
if (vm.SBSampleTimeMultiplier != 1 || vm.SBSampleTimeOffset != 0)
{
foreach (StoryboardSoundSample ss in beatmap.StoryboardSoundSamples)
{
if (Filter(ss.StartTime, ss.StartTime, vm))
{
ss.StartTime =
(int)Math.Round(ss.StartTime * vm.SBSampleTimeMultiplier + vm.SBSampleTimeOffset);
}
}
}
UpdateProgressBar(worker, 60);
// Break time
if (vm.BreakTimeMultiplier != 1 || vm.BreakTimeOffset != 0)
{
foreach (Break br in beatmap.BreakPeriods)
{
if (Filter(br.StartTime, br.StartTime, vm))
{
br.StartTime =
(int)Math.Round(br.StartTime * vm.BreakTimeMultiplier + vm.BreakTimeOffset);
}
if (Filter(br.EndTime, br.EndTime, vm))
{
br.EndTime = (int)Math.Round(br.EndTime * vm.BreakTimeMultiplier + vm.BreakTimeOffset);
}
}
}
UpdateProgressBar(worker, 70);
// Video start time
if (vm.VideoTimeMultiplier != 1 || vm.VideoTimeOffset != 0)
{
foreach (Event ev in beatmap.BackgroundAndVideoEvents)
{
if (ev is Video video)
{
if (Filter(video.StartTime, video.StartTime, vm))
{
video.StartTime =
(int)Math.Round(video.StartTime * vm.VideoTimeMultiplier + vm.VideoTimeOffset);
}
}
}
}
UpdateProgressBar(worker, 80);
// Preview point time
if (vm.PreviewTimeMultiplier != 1 || vm.PreviewTimeOffset != 0)
{
if (beatmap.General.ContainsKey("PreviewTime") &&
beatmap.General["PreviewTime"].IntValue != -1)
{
var previewTime = beatmap.General["PreviewTime"].DoubleValue;
if (Filter(previewTime, previewTime, vm))
{
var newPreviewTime =
Math.Round(previewTime * vm.PreviewTimeMultiplier + vm.PreviewTimeOffset);
beatmap.General["PreviewTime"].SetDouble(newPreviewTime);
}
}
}
UpdateProgressBar(worker, 90);
TimingPointsChange.ApplyChanges(beatmap.BeatmapTiming, timingPointsChanges);
// Save the file
beatmapEditor.SaveFile();
UpdateProgressBar(worker, 100);
}
else if (editor is StoryboardEditor storyboardEditor)
{
StoryBoard storyboard = storyboardEditor.StoryBoard;
// Storyboarded event time
if (vm.SBEventTimeMultiplier != 1 || vm.SBEventTimeOffset != 0)
{
foreach (Event ev in storyboard.StoryboardLayerBackground.Concat(storyboard.StoryboardLayerFail)
.Concat(storyboard.StoryboardLayerPass).Concat(storyboard.StoryboardLayerForeground)
.Concat(storyboard.StoryboardLayerOverlay))
{
TransformEventTime(ev, vm.SBEventTimeMultiplier, vm.SBEventTimeOffset, vm);
}
}
UpdateProgressBar(worker, 50);
// Storyboarded sample time
if (vm.SBSampleTimeMultiplier != 1 || vm.SBSampleTimeOffset != 0)
{
foreach (StoryboardSoundSample ss in storyboard.StoryboardSoundSamples)
{
if (Filter(ss.StartTime, ss.StartTime, vm))
{
ss.StartTime =
(int)Math.Round(ss.StartTime * vm.SBSampleTimeMultiplier + vm.SBSampleTimeOffset);
}
}
}
UpdateProgressBar(worker, 70);
// Video start time
if (vm.VideoTimeMultiplier != 1 || vm.VideoTimeOffset != 0)
{
foreach (Event ev in storyboard.BackgroundAndVideoEvents)
{
if (ev is Video video)
{
if (Filter(video.StartTime, video.StartTime, vm))
{
video.StartTime =
(int)Math.Round(video.StartTime * vm.VideoTimeMultiplier + vm.VideoTimeOffset);
}
}
}
}
UpdateProgressBar(worker, 90);
// Save the file
storyboardEditor.SaveFile();
UpdateProgressBar(worker, 100);
}
}
return("Done!");
}
private string TransformProperties(PropertyTransformerVm vm, BackgroundWorker worker, DoWorkEventArgs _)
{
bool doFilterMatch = vm.MatchFilter != -1 && vm.EnableFilters;
bool doFilterRange = (vm.MinTimeFilter != -1 || vm.MaxTimeFilter != -1) && vm.EnableFilters;
double min = vm.MinTimeFilter == -1 ? double.NegativeInfinity : vm.MinTimeFilter;
double max = vm.MaxTimeFilter == -1 ? double.PositiveInfinity : vm.MaxTimeFilter;
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
foreach (string path in vm.ExportPaths)
{
var editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader);
Beatmap beatmap = editor.Beatmap;
// Count all the total amount of things to loop through
int loops = 0;
int totalLoops = beatmap.BeatmapTiming.TimingPoints.Count;
if (vm.HitObjectTimeMultiplier != 1 || vm.HitObjectTimeOffset != 0)
{
totalLoops += beatmap.HitObjects.Count;
}
if (vm.BookmarkTimeMultiplier != 1 || vm.BookmarkTimeOffset != 0)
{
totalLoops += beatmap.GetBookmarks().Count;
}
if (vm.SBSampleTimeMultiplier != 1 || vm.SBSampleTimeOffset != 0)
{
totalLoops += beatmap.StoryboardSoundSamples.Count;
}
List <TimingPointsChange> timingPointsChanges = new List <TimingPointsChange>();
foreach (TimingPoint tp in beatmap.BeatmapTiming.TimingPoints)
{
// Offset
if (vm.TimingpointOffsetMultiplier != 1 || vm.TimingpointOffsetOffset != 0)
{
if (Filter(tp.Offset, tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
tp.Offset = Math.Round(tp.Offset * vm.TimingpointOffsetMultiplier + vm.TimingpointOffsetOffset);
}
}
// BPM
if (vm.TimingpointBPMMultiplier != 1 || vm.TimingpointBPMOffset != 0)
{
if (tp.Uninherited)
{
if (Filter(tp.GetBpm(), tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
double newBPM = tp.GetBpm() * vm.TimingpointBPMMultiplier + vm.TimingpointBPMOffset;
newBPM = vm.ClipProperties ? MathHelper.Clamp(newBPM, 15, 10000) : newBPM; // Clip the value if specified
tp.MpB = 60000 / newBPM;
}
}
}
// Slider Velocity
if (vm.TimingpointSVMultiplier != 1 || vm.TimingpointSVOffset != 0)
{
if (Filter(beatmap.BeatmapTiming.GetSvMultiplierAtTime(tp.Offset), tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
TimingPoint tpchanger = tp.Copy();
double newSV = beatmap.BeatmapTiming.GetSvMultiplierAtTime(tp.Offset) * vm.TimingpointSVMultiplier + vm.TimingpointSVOffset;
newSV = vm.ClipProperties ? MathHelper.Clamp(newSV, 0.1, 10) : newSV; // Clip the value if specified
tpchanger.MpB = -100 / newSV;
timingPointsChanges.Add(new TimingPointsChange(tpchanger, mpb: true));
}
}
// Index
if (vm.TimingpointIndexMultiplier != 1 || vm.TimingpointIndexOffset != 0)
{
if (Filter(tp.SampleIndex, tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
int newIndex = (int)Math.Round(tp.SampleIndex * vm.TimingpointIndexMultiplier + vm.TimingpointIndexOffset);
tp.SampleIndex = vm.ClipProperties ? MathHelper.Clamp(newIndex, 0, 100) : newIndex;
}
}
// Volume
if (vm.TimingpointVolumeMultiplier != 1 || vm.TimingpointVolumeOffset != 0)
{
if (Filter(tp.Volume, tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
int newVolume = (int)Math.Round(tp.Volume * vm.TimingpointVolumeMultiplier + vm.TimingpointVolumeOffset);
tp.Volume = vm.ClipProperties ? MathHelper.Clamp(newVolume, 5, 100) : newVolume;
}
}
// Update progress bar
loops++;
UpdateProgressBar(worker, loops * 100 / totalLoops);
}
// Hitobject Time
if (vm.HitObjectTimeMultiplier != 1 || vm.HitObjectTimeOffset != 0)
{
foreach (HitObject ho in beatmap.HitObjects)
{
if (Filter(ho.Time, ho.Time, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
ho.Time = Math.Round(ho.Time * vm.HitObjectTimeMultiplier + vm.HitObjectTimeOffset);
}
// Update progress bar
loops++;
UpdateProgressBar(worker, loops * 100 / totalLoops);
}
}
// Bookmark Time
if (vm.BookmarkTimeMultiplier != 1 || vm.BookmarkTimeOffset != 0)
{
List <double> newBookmarks = new List <double>();
List <double> bookmarks = beatmap.GetBookmarks();
foreach (double bookmark in bookmarks)
{
if (Filter(bookmark, bookmark, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
newBookmarks.Add(Math.Round(bookmark * vm.BookmarkTimeMultiplier + vm.BookmarkTimeOffset));
}
else
{
newBookmarks.Add(bookmark);
}
// Update progress bar
loops++;
UpdateProgressBar(worker, loops * 100 / totalLoops);
}
beatmap.SetBookmarks(newBookmarks);
}
// Storyboarded sample Time
if (vm.SBSampleTimeMultiplier != 1 || vm.SBSampleTimeOffset != 0)
{
foreach (StoryboardSoundSample ss in beatmap.StoryboardSoundSamples)
{
if (Filter(ss.Time, ss.Time, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
ss.Time = Math.Round(ss.Time * vm.SBSampleTimeMultiplier + vm.SBSampleTimeOffset);
}
// Update progress bar
loops++;
UpdateProgressBar(worker, loops * 100 / totalLoops);
}
}
// Preview point time
if (vm.PreviewTimeMultiplier != 1 || vm.PreviewTimeOffset != 0)
{
if (beatmap.General.ContainsKey("PreviewTime") && beatmap.General["PreviewTime"].IntValue != -1)
{
var previewTime = beatmap.General["PreviewTime"].DoubleValue;
if (Filter(previewTime, previewTime, doFilterMatch, doFilterRange, vm.MatchFilter, min, max))
{
var newPreviewTime = Math.Round(previewTime * vm.PreviewTimeMultiplier + vm.PreviewTimeOffset);
beatmap.General["PreviewTime"].SetDouble(newPreviewTime);
}
}
}
TimingPointsChange.ApplyChanges(beatmap.BeatmapTiming, timingPointsChanges);
// Save the file
editor.SaveFile();
}
return("Done!");
}
private string Copy_Hitsounds(HitsoundCopierVm arg, BackgroundWorker worker)
{
var doMutedIndex = arg.MutedIndex >= 0;
var paths = arg.PathTo.Split('|');
var mapsDone = 0;
var sampleSchema = new SampleSchema();
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
foreach (var pathTo in paths)
{
BeatmapEditor editorTo = EditorReaderStuff.GetNewestVersionOrNot(pathTo, reader);;
Beatmap beatmapTo = editorTo.Beatmap;
Beatmap beatmapFrom;
if (!string.IsNullOrEmpty(arg.PathFrom))
{
var editorFrom = EditorReaderStuff.GetNewestVersionOrNot(arg.PathFrom, reader);
beatmapFrom = editorFrom.Beatmap;
}
else
{
// Copy from an empty beatmap similar to the map to copy to
beatmapFrom = beatmapTo.DeepCopy();
beatmapFrom.HitObjects.Clear();
beatmapFrom.BeatmapTiming.Clear();
}
Timeline processedTimeline;
if (arg.CopyMode == 0)
{
// Every defined hitsound and sampleset on hitsound gets copied to their copyTo destination
// Timelines
var tlTo = beatmapTo.GetTimeline();
var tlFrom = beatmapFrom.GetTimeline();
var volumeMuteTimes = arg.CopyVolumes && arg.AlwaysPreserve5Volume ? new List <double>() : null;
if (arg.CopyHitsounds)
{
ResetHitObjectHitsounds(beatmapTo);
CopyHitsounds(arg, tlFrom, tlTo);
}
// Save tlo times where timingpoint volume is 5%
// Timingpointchange all the undefined tlo from copyFrom
volumeMuteTimes?.AddRange(from tloTo in tlTo.TimelineObjects
where tloTo.CanCopy && Math.Abs(tloTo.SampleVolume) < Precision.DOUBLE_EPSILON &&
Math.Abs(tloTo.FenoSampleVolume - 5) < Precision.DOUBLE_EPSILON
select tloTo.Time);
// Volumes and samplesets and customindices greenlines get copied with timingpointchanges and allafter enabled
var timingPointsChanges = beatmapFrom.BeatmapTiming.TimingPoints.Select(tp =>
new TimingPointsChange(tp, sampleset: arg.CopySampleSets, index: arg.CopySampleSets,
volume: arg.CopyVolumes)).ToList();
// Apply the timingpoint changes
TimingPointsChange.ApplyChanges(beatmapTo.BeatmapTiming, timingPointsChanges, true);
processedTimeline = tlTo;
// Return 5% volume to tlo that had it before
if (volumeMuteTimes != null)
{
var timingPointsChangesMute = new List <TimingPointsChange>();
processedTimeline.GiveTimingPoints(beatmapTo.BeatmapTiming);
// Exclude objects which use their own sample volume property instead
foreach (var tloTo in processedTimeline.TimelineObjects.Where(o => Math.Abs(o.SampleVolume) < Precision.DOUBLE_EPSILON))
{
if (volumeMuteTimes.Contains(tloTo.Time))
{
// Add timingpointschange to copy timingpoint hitsounds
var tp = tloTo.HitsoundTimingPoint.Copy();
tp.Offset = tloTo.Time;
tp.Volume = 5;
timingPointsChangesMute.Add(new TimingPointsChange(tp, volume: true));
}
else
{
// Add timingpointschange to preserve index and volume
var tp = tloTo.HitsoundTimingPoint.Copy();
tp.Offset = tloTo.Time;
tp.Volume = tloTo.FenoSampleVolume;
timingPointsChangesMute.Add(new TimingPointsChange(tp, volume: true));
}
}
// Apply the timingpoint changes
TimingPointsChange.ApplyChanges(beatmapTo.BeatmapTiming, timingPointsChangesMute);
}
}
else
{
// Smarty mode
// Copy the defined hitsounds literally (not feno, that will be reserved for cleaner). Only the tlo that have been defined by copyFrom get overwritten.
var tlTo = beatmapTo.GetTimeline();
var tlFrom = beatmapFrom.GetTimeline();
var timingPointsChanges = new List <TimingPointsChange>();
var mode = (GameMode)beatmapTo.General["Mode"].IntValue;
var mapDir = editorTo.GetParentFolder();
var firstSamples = HitsoundImporter.AnalyzeSamples(mapDir);
if (arg.CopyHitsounds)
{
CopyHitsounds(arg, beatmapTo, tlFrom, tlTo, timingPointsChanges, mode, mapDir, firstSamples, ref sampleSchema);
}
if (arg.CopyBodyHitsounds)
{
// Remove timingpoints in beatmapTo that are in a sliderbody/spinnerbody for both beatmapTo and BeatmapFrom
foreach (var tp in from ho in beatmapTo.HitObjects
from tp in ho.BodyHitsounds
where beatmapFrom.HitObjects.Any(o => o.Time <tp.Offset && o.EndTime> tp.Offset)
where !tp.Uninherited
select tp)
{
beatmapTo.BeatmapTiming.Remove(tp);
}
// Get timingpointschanges for every timingpoint from beatmapFrom that is in a sliderbody/spinnerbody for both beatmapTo and BeatmapFrom
timingPointsChanges.AddRange(from ho in beatmapFrom.HitObjects
from tp in ho.BodyHitsounds
where beatmapTo.HitObjects.Any(o => o.Time <tp.Offset && o.EndTime> tp.Offset)
select new TimingPointsChange(tp.Copy(), sampleset: arg.CopySampleSets, index: arg.CopySampleSets,
volume: arg.CopyVolumes));
}
// Apply the timingpoint changes
TimingPointsChange.ApplyChanges(beatmapTo.BeatmapTiming, timingPointsChanges);
processedTimeline = tlTo;
}
if (arg.CopyStoryboardedSamples)
{
if (arg.CopyMode == 0)
{
beatmapTo.StoryboardSoundSamples.Clear();
}
beatmapTo.GiveObjectsGreenlines();
processedTimeline.GiveTimingPoints(beatmapTo.BeatmapTiming);
var mapDir = editorTo.GetParentFolder();
var firstSamples = HitsoundImporter.AnalyzeSamples(mapDir, true);
var samplesTo = new HashSet <StoryboardSoundSample>(beatmapTo.StoryboardSoundSamples);
var mode = (GameMode)beatmapTo.General["Mode"].IntValue;
foreach (var sampleFrom in beatmapFrom.StoryboardSoundSamples)
{
if (arg.IgnoreHitsoundSatisfiedSamples)
{
var tloHere = processedTimeline.TimelineObjects.FindAll(o =>
Math.Abs(o.Time - sampleFrom.StartTime) <= arg.TemporalLeniency);
var samplesHere = new HashSet <string>();
foreach (var tlo in tloHere)
{
foreach (var filename in tlo.GetPlayingFilenames(mode))
{
var samplePath = Path.Combine(mapDir, filename);
var fullPathExtLess = Path.Combine(Path.GetDirectoryName(samplePath),
Path.GetFileNameWithoutExtension(samplePath));
if (firstSamples.Keys.Contains(fullPathExtLess))
{
samplePath = firstSamples[fullPathExtLess];
}
samplesHere.Add(samplePath);
}
}
var sbSamplePath = Path.Combine(mapDir, sampleFrom.FilePath);
var sbFullPathExtLess = Path.Combine(Path.GetDirectoryName(sbSamplePath),
Path.GetFileNameWithoutExtension(sbSamplePath));
if (firstSamples.Keys.Contains(sbFullPathExtLess))
{
sbSamplePath = firstSamples[sbFullPathExtLess];
}
if (samplesHere.Contains(sbSamplePath))
{
continue;
}
}
// Add the StoryboardSoundSamples from beatmapFrom to beatmapTo if it doesn't already have the sample
if (!samplesTo.Contains(sampleFrom))
{
beatmapTo.StoryboardSoundSamples.Add(sampleFrom);
}
}
// Sort the storyboarded samples
beatmapTo.StoryboardSoundSamples.Sort();
}
if (arg.MuteSliderends)
{
var timingPointsChanges = new List <TimingPointsChange>();
beatmapTo.GiveObjectsGreenlines();
processedTimeline.GiveTimingPoints(beatmapTo.BeatmapTiming);
foreach (var tloTo in processedTimeline.TimelineObjects)
{
if (FilterMuteTlo(tloTo, beatmapTo, arg))
{
// Set volume to 5%, remove all hitsounds, apply customindex and sampleset
tloTo.SampleSet = arg.MutedSampleSet;
tloTo.AdditionSet = 0;
tloTo.Normal = false;
tloTo.Whistle = false;
tloTo.Finish = false;
tloTo.Clap = false;
tloTo.HitsoundsToOrigin();
// Add timingpointschange to copy timingpoint hitsounds
var tp = tloTo.HitsoundTimingPoint.Copy();
tp.Offset = tloTo.Time;
tp.SampleSet = arg.MutedSampleSet;
tp.SampleIndex = arg.MutedIndex;
tp.Volume = 5;
timingPointsChanges.Add(new TimingPointsChange(tp, sampleset: true, index: doMutedIndex,
volume: true));
}
else
{
// Add timingpointschange to preserve index and volume and sampleset
var tp = tloTo.HitsoundTimingPoint.Copy();
tp.Offset = tloTo.Time;
timingPointsChanges.Add(new TimingPointsChange(tp, sampleset: true, index: doMutedIndex,
volume: true));
}
}
// Apply the timingpoint changes
TimingPointsChange.ApplyChanges(beatmapTo.BeatmapTiming, timingPointsChanges);
}
// Save the file
editorTo.SaveFile();
// Export the sample schema if there are samples
if (sampleSchema.Count > 0)
{
string exportFolder = MainWindow.ExportPath;
DirectoryInfo di = new DirectoryInfo(exportFolder);
foreach (FileInfo file in di.GetFiles())
{
file.Delete();
}
HitsoundExporter.ExportSampleSchema(sampleSchema, exportFolder);
System.Diagnostics.Process.Start(exportFolder);
}
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(++mapsDone * 100 / paths.Length);
}
}
return("Done!");
}
private string ExportPattern(PatternGalleryVm args, BackgroundWorker worker, DoWorkEventArgs _)
{
EditorReader reader;
double exportTime = 0;
bool usePatternOffset = false;
switch (args.ExportTimeMode)
{
case ExportTimeMode.Current:
try {
reader = EditorReaderStuff.GetFullEditorReader();
exportTime = reader.EditorTime();
}
catch (Exception e) {
throw new Exception("Could not fetch the current editor time.", e);
}
break;
case ExportTimeMode.Pattern:
reader = EditorReaderStuff.GetFullEditorReaderOrNot();
usePatternOffset = true;
break;
case ExportTimeMode.Custom:
reader = EditorReaderStuff.GetFullEditorReaderOrNot();
exportTime = args.CustomExportTime;
break;
default:
throw new ArgumentOutOfRangeException(nameof(ExportTimeMode), "Invalid value encountered");
}
var editor = EditorReaderStuff.GetNewestVersionOrNot(args.Paths[0], reader);
var patternCount = args.Patterns.Count(o => o.IsSelected);
if (patternCount == 0)
{
throw new Exception("No pattern has been selected to export.");
}
var patternPlacer = args.OsuPatternPlacer;
foreach (var pattern in args.Patterns.Where(o => o.IsSelected))
{
var patternBeatmap = pattern.GetPatternBeatmap(args.FileHandler);
if (usePatternOffset)
{
patternPlacer.PlaceOsuPattern(patternBeatmap, editor.Beatmap, protectBeatmapPattern: false);
}
else
{
patternPlacer.PlaceOsuPatternAtTime(patternBeatmap, editor.Beatmap, exportTime, false);
}
// Increase pattern use count and time
pattern.UseCount++;
pattern.LastUsedTime = DateTime.Now;
}
editor.SaveFile();
// Complete progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(100);
}
// Do stuff
RunFinished?.Invoke(this, new RunToolCompletedEventArgs(true, reader != null, args.Quick));
return("Successfully exported pattern!");
}
private string Copy_Timing(TimingCopierVm arg, BackgroundWorker worker, DoWorkEventArgs _)
{
string[] paths = arg.ExportPath.Split('|');
int mapsDone = 0;
var reader = EditorReaderStuff.GetFullEditorReaderOrNot();
foreach (string exportPath in paths)
{
var editorTo = EditorReaderStuff.GetNewestVersionOrNot(exportPath, reader);
var editorFrom = EditorReaderStuff.GetNewestVersionOrNot(arg.ImportPath, reader);
Beatmap beatmapTo = editorTo.Beatmap;
Beatmap beatmapFrom = editorFrom.Beatmap;
Timing timingTo = beatmapTo.BeatmapTiming;
Timing timingFrom = beatmapFrom.BeatmapTiming;
// Get markers for hitobjects if mode 1 is used
List <Marker> markers = new List <Marker>();
if (arg.ResnapMode == "Number of beats between objects stays the same")
{
markers = GetMarkers(beatmapTo, timingTo);
}
// Rid the beatmap of redlines
// If a greenline exists at the same time as a redline then the redline ceizes to exist
// Else convert the redline to a greenline: Inherited = false & MpB = -100
List <TimingPoint> removeList = new List <TimingPoint>();
foreach (TimingPoint redline in timingTo.GetAllRedlines())
{
TimingPoint greenlineHere = timingTo.GetGreenlineAtTime(redline.Offset);
if (greenlineHere.Offset == redline.Offset)
{
removeList.Add(redline);
}
else
{
redline.Uninherited = false;
redline.MpB = -100;
}
}
foreach (TimingPoint tp in removeList)
{
timingTo.TimingPoints.Remove(tp);
}
// Make new timing points changes
List <TimingPointsChange> timingPointsChanges = new List <TimingPointsChange>();
// Add redlines
List <TimingPoint> redlines = timingFrom.GetAllRedlines();
foreach (TimingPoint tp in redlines)
{
timingPointsChanges.Add(new TimingPointsChange(tp, mpb: true, meter: true, inherited: true, omitFirstBarLine: true));
}
// Apply timing changes
TimingPointsChange.ApplyChanges(timingTo, timingPointsChanges);
if (arg.ResnapMode == "Number of beats between objects stays the same")
{
redlines = timingTo.GetAllRedlines();
List <double> newBookmarks = new List <double>();
double lastTime = redlines.FirstOrDefault().Offset;
foreach (Marker marker in markers)
{
// Get redlines between this and last marker
TimingPoint redline = timingTo.GetRedlineAtTime(lastTime, redlines.FirstOrDefault());
double beatsFromLastTime = marker.BeatsFromLastMarker;
while (true)
{
List <TimingPoint> redlinesBetween = redlines.Where(o => o.Offset <= lastTime + redline.MpB * beatsFromLastTime && o.Offset > lastTime).ToList();
if (redlinesBetween.Count == 0)
{
break;
}
TimingPoint first = redlinesBetween.First();
double diff = first.Offset - lastTime;
beatsFromLastTime -= diff / redline.MpB;
redline = first;
lastTime = first.Offset;
}
// Last time is the time of the last redline in between
double newTime = lastTime + redline.MpB * beatsFromLastTime;
newTime = timingTo.Resnap(newTime, arg.Snap1, arg.Snap2, firstTp: redlines.FirstOrDefault());
marker.Time = newTime;
lastTime = marker.Time;
}
// Add the bookmarks
foreach (Marker marker in markers)
{
// Check whether the marker is a bookmark
if (marker.Object is double)
{
// Don't resnap bookmarks
newBookmarks.Add((double)marker.Object);
}
}
beatmapTo.SetBookmarks(newBookmarks);
}
else if (arg.ResnapMode == "Just resnap")
{
// Resnap hitobjects
foreach (HitObject ho in beatmapTo.HitObjects)
{
ho.ResnapSelf(timingTo, arg.Snap1, arg.Snap2, firstTp: redlines.FirstOrDefault());
ho.ResnapEnd(timingTo, arg.Snap1, arg.Snap2, firstTp: redlines.FirstOrDefault());
}
// Resnap greenlines
foreach (TimingPoint tp in timingTo.GetAllGreenlines())
{
tp.ResnapSelf(timingTo, arg.Snap1, arg.Snap2, firstTP: redlines.FirstOrDefault());
}
}
else
{
// Don't move objects
}
// Save the file
editorTo.SaveFile();
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(++mapsDone * 100 / paths.Length);
}
}
// Make an accurate message
string message = $"Successfully copied timing to {mapsDone} {(mapsDone == 1 ? "beatmap" : "beatmaps")}!";
return(message);
}
private string Sliderate(SlideratorVm arg, BackgroundWorker worker)
{
// Make a position function for Sliderator
Classes.Tools.Sliderator.PositionFunctionDelegate positionFunction;
// Test if the function is a constant velocity
bool constantVelocity;
// We convert the graph GetValue function to a function that works like ms -> px
// d is a value representing the number of milliseconds into the slider
if (arg.GraphModeSetting == SlideratorVm.GraphMode.Velocity)
{
// Here we use SvGraphMultiplier to get an accurate conversion from SV to slider completion per beat
// Completion = (100 * SliderMultiplier / PixelLength) * SV * Beats
positionFunction = d =>
arg.GraphState.GetIntegral(0, d * arg.BeatsPerMinute / 60000) * arg.SvGraphMultiplier *
arg.PixelLength;
constantVelocity = Precision.AlmostEquals(AnchorCollection.GetMaxValue(arg.GraphState.Anchors),
AnchorCollection.GetMinValue(arg.GraphState.Anchors));
}
else
{
positionFunction = d => arg.GraphState.GetValue(d * arg.BeatsPerMinute / 60000) * arg.PixelLength;
constantVelocity = Precision.AlmostEquals(AnchorCollection.GetMaxDerivative(arg.GraphState.Anchors),
AnchorCollection.GetMinDerivative(arg.GraphState.Anchors));
}
// Dont do Sliderator if the velocity is constant AND equal to the new velocity
var simplifyShape = constantVelocity && Precision.AlmostEquals(
arg.PixelLength / arg.GraphBeats / arg.GlobalSv / 100,
arg.NewVelocity);
// Get the highest velocity occuring in the graph
double velocity = arg.NewVelocity; // Velocity is in SV
// Do bad stuff to the velocity to make sure its the same SV as after writing it to .osu code
velocity = -100 / double.Parse((-100 / velocity).ToInvariant(), CultureInfo.InvariantCulture);
// Other velocity is in px / ms
var otherVelocity = velocity * arg.SvGraphMultiplier * arg.PixelLength * arg.BeatsPerMinute / 60000;
// Time between timeline ticks for stream export
var deltaT = 60000 / arg.BeatsPerMinute / arg.BeatSnapDivisor;
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(10);
}
List <Vector2> slideration = new List <Vector2>();
var sliderator = new Classes.Tools.Sliderator {
PositionFunction = positionFunction, MaxT = arg.GraphBeats / arg.BeatsPerMinute * 60000,
Velocity = otherVelocity,
MinDendriteLength = arg.MinDendrite
};
if (!simplifyShape)
{
// Get slider path like from the hit object preview
var sliderPath = new SliderPath(arg.VisibleHitObject.SliderType,
arg.VisibleHitObject.GetAllCurvePoints().ToArray(),
GetMaxCompletion(arg, arg.GraphState.Anchors) * arg.PixelLength);
var path = new List <Vector2>();
sliderPath.GetPathToProgress(path, 0, 1);
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(20);
}
// Do Sliderator
sliderator.SetPath(path);
slideration = arg.ExportAsStream ?
sliderator.SliderateStream(deltaT) :
sliderator.Sliderate();
// Check for some illegal output
if (double.IsInfinity(sliderator.MaxS) || double.IsNaN(sliderator.MaxS) ||
slideration.Any(v => double.IsNaN(v.X) || double.IsNaN(v.Y)))
{
return("Encountered unexpected values from Sliderator. Please check your input.");
}
}
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(60);
}
// Exporting stuff
BeatmapEditor editor;
bool editorRead = false;
if (arg.DoEditorRead)
{
editor = EditorReaderStuff.GetNewestVersionOrNot(arg.Path, out _, out var exception);
if (exception == null)
{
editorRead = true;
}
arg.DoEditorRead = false;
}
else
{
editor = new BeatmapEditor(arg.Path);
}
var beatmap = editor.Beatmap;
var timing = beatmap.BeatmapTiming;
// Get hit object that might be present at the export time or make a new one
var hitObjectHere = beatmap.HitObjects.FirstOrDefault(o => Math.Abs(arg.ExportTime - o.Time) < 5) ??
new HitObject(arg.ExportTime, 0, SampleSet.Auto, SampleSet.Auto);
// Clone the hit object to not affect the already existing hit object instance with changes
var clone = new HitObject(hitObjectHere.GetLine())
{
IsCircle = arg.ExportAsStream, IsSpinner = false, IsHoldNote = false, IsSlider = !arg.ExportAsStream
};
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(70);
}
if (!arg.ExportAsStream)
{
// Give the new hit object the sliderated anchors
if (simplifyShape)
{
// The velocity is constant, so you can simplify to the original slider shape
clone.SetAllCurvePoints(arg.VisibleHitObject.GetAllCurvePoints());
clone.SliderType = arg.VisibleHitObject.SliderType;
}
else
{
clone.SetAllCurvePoints(slideration);
clone.SliderType = PathType.Bezier;
}
clone.PixelLength = sliderator.MaxS;
clone.SliderVelocity = -100 / velocity;
// Add hit object
if (arg.ExportModeSetting == SlideratorVm.ExportMode.Add)
{
beatmap.HitObjects.Add(clone);
}
else
{
beatmap.HitObjects.Remove(hitObjectHere);
beatmap.HitObjects.Add(clone);
}
// Add SV
var timingPointsChanges = new List <TimingPointsChange>();
if (arg.DelegateToBpm)
{
var tpAfter = timing.GetRedlineAtTime(clone.Time).Copy();
var tpOn = tpAfter.Copy();
tpAfter.Offset = clone.Time;
tpOn.Offset = clone.Time - 1; // This one will be on the slider
tpAfter.OmitFirstBarLine = true;
tpOn.OmitFirstBarLine = true;
// Express velocity in BPM
tpOn.MpB /= -100 / clone.SliderVelocity;
// NaN SV results in removal of slider ticks
clone.SliderVelocity = arg.RemoveSliderTicks ? double.NaN : -100;
// Add redlines
timingPointsChanges.Add(new TimingPointsChange(tpOn, mpb: true, inherited: true, omitFirstBarLine: true, fuzzyness: 0));
timingPointsChanges.Add(new TimingPointsChange(tpAfter, mpb: true, inherited: true, omitFirstBarLine: true, fuzzyness: 0));
clone.Time -= 1;
}
// Add SV for every hit object so the SV doesnt change for anything else than the sliderated slider
timingPointsChanges.AddRange(beatmap.HitObjects.Select(ho => {
var sv = ho == clone ? ho.SliderVelocity : timing.GetSvAtTime(ho.Time);
var tp = timing.GetTimingPointAtTime(ho.Time).Copy();
tp.MpB = sv;
tp.Offset = ho.Time;
return(new TimingPointsChange(tp, mpb: true, fuzzyness: 0));
}));
TimingPointsChange.ApplyChanges(timing, timingPointsChanges);
}
else
{
// Add hit objects
if (arg.ExportModeSetting == SlideratorVm.ExportMode.Override)
{
beatmap.HitObjects.Remove(hitObjectHere);
}
double t = arg.ExportTime;
foreach (var pos in slideration)
{
clone.Pos = pos;
clone.Time = t;
beatmap.HitObjects.Add(clone);
clone = new HitObject(clone.GetLine())
{
IsCircle = true, IsSpinner = false, IsHoldNote = false, IsSlider = false, NewCombo = false
};
t += deltaT;
}
}
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(80);
}
beatmap.SortHitObjects();
editor.SaveFile();
// Complete progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(100);
}
// Do stuff
if (arg.Quick)
{
RunFinished?.Invoke(this, new RunToolCompletedEventArgs(true, editorRead));
}
return(arg.Quick ? string.Empty : "Done!");
}