public HitsoundPreviewHelperVm()
{
_items = new ObservableCollection <HitsoundZone>();
RhythmGuideCommand = new CommandImplementation(
_ => {
try {
if (_rhythmGuideWindow == null)
{
_rhythmGuideWindow = new RhythmGuideWindow();
_rhythmGuideWindow.Closed += RhythmGuideWindowOnClosed;
_rhythmGuideWindow.Show();
}
else
{
_rhythmGuideWindow.Focus();
}
} catch (Exception ex) { ex.Show(); }
});
AddCommand = new CommandImplementation(
_ => {
try {
var newZone = new HitsoundZone();
if (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift))
{
var editor = EditorReaderStuff.GetBeatmapEditor(EditorReaderStuff.GetFullEditorReader(),
out var selected);
if (selected.Count > 0)
{
newZone.XPos = selected[0].Pos.X;
newZone.YPos = editor.Beatmap.General["Mode"].IntValue == 3 ? -1 : selected[0].Pos.Y;
}
else
{
MessageBox.Show("Please select a hit object to fetch the coordinates.");
}
}
Items.Add(newZone);
} catch (Exception ex) { ex.Show(); }
});
CopyCommand = new CommandImplementation(
_ => {
try {
int initialCount = Items.Count;
for (int i = 0; i < initialCount; i++)
{
if (Items[i].IsSelected)
{
Items.Add(Items[i].Copy());
}
}
} catch (Exception ex) { ex.Show(); }
});
RemoveCommand = new CommandImplementation(
_ => {
try {
Items.RemoveAll(o => o.IsSelected);
} catch (Exception ex) { ex.Show(); }
});
}
private string PlaceHitsounds(Arguments args, BackgroundWorker worker, DoWorkEventArgs _)
{
if (args.Zones.Count == 0)
{
return("There are no zones!");
}
bool editorRead = EditorReaderStuff.TryGetFullEditorReader(out var reader);
foreach (string path in args.Paths)
{
var editor = EditorReaderStuff.GetBeatmapEditor(path, reader, editorRead);
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;
}
}
tlo.Filename = column.Filename;
tlo.SampleSet = column.SampleSet;
tlo.AdditionSet = SampleSet.Auto;
tlo.SetHitsound(column.Hitsound);
tlo.HitsoundsToOrigin();
UpdateProgressBar(worker, (int)(100f * i / beatmap.HitObjects.Count));
}
// Save the file
editor.SaveFile();
}
// Do stuff
if (args.Quick)
{
RunFinished?.Invoke(this, new RunToolCompletedEventArgs(true, editorRead));
}
return(args.Quick ? "" : "Done!");
}
private string Run_Program(Arguments args, BackgroundWorker worker, DoWorkEventArgs _) {
var result = new MapCleaner.MapCleanerResult();
bool editorRead = EditorReaderStuff.TryGetFullEditorReader(out var reader);
if (args.Paths.Length == 1) {
var editor = EditorReaderStuff.GetBeatmapEditor(args.Paths[0], reader, editorRead);
List<TimingPoint> orgininalTimingPoints = new List<TimingPoint>();
foreach (TimingPoint tp in editor.Beatmap.BeatmapTiming.TimingPoints) { orgininalTimingPoints.Add(tp.Copy()); }
int oldTimingPointsCount = editor.Beatmap.BeatmapTiming.TimingPoints.Count;
result.Add(MapCleaner.CleanMap(editor, args.CleanerArguments, 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.GetBeatmapEditor(path, reader, editorRead);
int oldTimingPointsCount = editor.Beatmap.BeatmapTiming.TimingPoints.Count;
result.Add(MapCleaner.CleanMap(editor, args.CleanerArguments, 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, editorRead));
// Make an accurate message
string message = $"Successfully {(result.TimingPointsRemoved < 0 ? "added" : "removed")} {Math.Abs(result.TimingPointsRemoved)} {(Math.Abs(result.TimingPointsRemoved) == 1 ? "greenline" : "greenlines")}" +
(args.CleanerArguments.ResnapObjects ? $" and resnapped {result.ObjectsResnapped} {(result.ObjectsResnapped == 1 ? "object" : "objects")}" : "") +
(args.CleanerArguments.RemoveUnusedSamples ? $" and removed {result.SamplesRemoved} unused {(result.SamplesRemoved == 1 ? "sample" : "samples")}" : "") + "!";
return args.Quick ? "" : message;
}
private static string Copy_Metadata(MetadataManagerVm arg, BackgroundWorker worker, DoWorkEventArgs _)
{
var paths = arg.ExportPath.Split('|');
var mapsDone = 0;
var editorRead = EditorReaderStuff.TryGetFullEditorReader(out var reader);
foreach (var path in paths)
{
var editor = EditorReaderStuff.GetBeatmapEditor(path, reader, editorRead);
var beatmap = editor.Beatmap;
beatmap.Metadata["ArtistUnicode"].StringValue = arg.Artist;
beatmap.Metadata["Artist"].StringValue = arg.RomanisedArtist;
beatmap.Metadata["TitleUnicode"].StringValue = arg.Title;
beatmap.Metadata["Title"].StringValue = arg.RomanisedTitle;
beatmap.Metadata["Creator"].StringValue = arg.BeatmapCreator;
beatmap.Metadata["Source"].StringValue = arg.Source;
beatmap.Metadata["Tags"].StringValue = 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
editor.SaveFile();
// 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 Merge_Sliders(Arguments arg, BackgroundWorker worker)
{
var slidersMerged = 0;
var editorRead = EditorReaderStuff.TryGetFullEditorReader(out var reader);
foreach (var path in arg.Paths)
{
var editor = EditorReaderStuff.GetBeatmapEditor(path, reader, editorRead, out var selected, out var editorActuallyRead);
if (arg.SelectionMode == 0 && !editorActuallyRead)
{
return(EditorReaderStuff.SelectedObjectsReadFailText);
}
var beatmap = editor.Beatmap;
var markedObjects = arg.SelectionMode == 0 ? selected :
arg.SelectionMode == 1 ? beatmap.GetBookmarkedObjects() :
beatmap.HitObjects;
var mergeLast = false;
for (var i = 0; i < markedObjects.Count - 1; i++)
{
var ho1 = markedObjects[i];
var ho2 = markedObjects[i + 1];
if (ho1.IsSlider && ho2.IsSlider && (ho1.CurvePoints.Last() - ho2.Pos).Length <= arg.Leniency)
{
var sp1 = BezierConverter.ConvertToBezier(ho1.SliderPath).ControlPoints;
var sp2 = BezierConverter.ConvertToBezier(ho2.SliderPath).ControlPoints;
double extraLength = 0;
switch (arg.ConnectionMode)
{
case ConnectionMode.Move:
Move(sp2, sp1.Last() - sp2.First());
break;
case 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 && (ho1.CurvePoints.Last() - ho2.Pos).Length <= arg.Leniency)
{
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 && (ho1.Pos - ho2.Pos).Length <= arg.Leniency)
{
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 && (ho1.Pos - ho2.Pos).Length <= arg.Leniency)
{
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;
}
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(i / markedObjects.Count);
}
}
// 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, editorRead));
}
// 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 Adjust_Timing(Arguments arg, BackgroundWorker worker, DoWorkEventArgs _)
{
// Count
int RedlinesAdded = 0;
bool editorRead = EditorReaderStuff.TryGetFullEditorReader(out var reader);
foreach (string path in arg.Paths)
{
// Open beatmap
var editor = EditorReaderStuff.GetBeatmapEditor(path, reader, editorRead);
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.Snap1, arg.Snap2, false, redline);
// Calculate beats from the redline
double beatsFromRedline = (resnappedTime - redline.Offset) / redline.MpB;
// Avoid problems
if (MathHelper.ApproximatelyEquivalent(beatsFromRedline, 0, 0.0001))
{
beatsFromRedline = 1 / Math.Max(arg.Snap1, arg.Snap2);
}
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.Snap1, arg.Snap2, false);
// Change the beats from last marker
beatsFromLastMarker = (resnappedTime - resnappedTimeL) / redline.MpB;
// Avoid problems
if (MathHelper.ApproximatelyEquivalent(beatsFromLastMarker, 0, 0.0001))
{
beatsFromLastMarker = 1f / Math.Max(arg.Snap1, arg.Snap2);
}
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.TimingPoints.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.TimingPoints.Add(newRedline);
timing.Sort();
// 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 string Copy_Hitsounds(Arguments arg, BackgroundWorker worker)
{
var copyMode = arg.CopyMode;
var temporalLeniency = arg.TemporalLeniency;
var copyHitsounds = arg.CopyHitsounds;
var copySliderbodychanges = arg.CopyBodyHitsounds;
var copyVolumes = arg.CopyVolumes;
var copySbSamples = arg.CopyStoryboardedSamples;
var ignoreHssbSamples = arg.IgnoreHitsoundSatisfiedSamples;
var copySamplesets = arg.CopySamplesets;
var muteSliderends = arg.MuteSliderends;
var doMutedIndex = arg.MutedIndex >= 0;
var paths = arg.PathTo.Split('|');
var mapsDone = 0;
var editorRead = EditorReaderStuff.TryGetFullEditorReader(out var reader);
foreach (var pathTo in paths)
{
var editorTo = EditorReaderStuff.GetBeatmapEditor(pathTo, reader, editorRead);
var editorFrom = EditorReaderStuff.GetBeatmapEditor(arg.PathFrom, reader, editorRead);
var beatmapTo = editorTo.Beatmap;
var beatmapFrom = editorFrom.Beatmap;
Timeline processedTimeline;
if (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 (copyHitsounds)
{
ResetHitObjectHitsounds(beatmapTo);
CopyHitsounds(arg, tlFrom, tlTo);
}
// Save tlo times where volume is 5%
// Timingpointchange all the undefined tlo from copyFrom
volumeMuteTimes?.AddRange(from tloTo in tlTo.TimelineObjects
where tloTo.CanCopy && 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: copySamplesets, index: copySamplesets,
volume: 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);
foreach (var tloTo in processedTimeline.TimelineObjects)
{
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"].Value;
var mapDir = editorTo.GetBeatmapFolder();
var firstSamples = HitsoundImporter.AnalyzeSamples(mapDir);
if (copyHitsounds)
{
CopyHitsounds(arg, tlFrom, tlTo, timingPointsChanges, mode, mapDir, firstSamples);
}
if (copySliderbodychanges)
{
// 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.TimingPoints.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: copySamplesets, index: copySamplesets,
volume: copyVolumes));
}
// Apply the timingpoint changes
TimingPointsChange.ApplyChanges(beatmapTo.BeatmapTiming, timingPointsChanges);
processedTimeline = tlTo;
}
if (copySbSamples)
{
if (copyMode == 0)
{
beatmapTo.StoryboardSoundSamples.Clear();
}
beatmapTo.GiveObjectsGreenlines();
processedTimeline.GiveTimingPoints(beatmapTo.BeatmapTiming);
var mapDir = editorTo.GetBeatmapFolder();
var firstSamples = HitsoundImporter.AnalyzeSamples(mapDir, true);
var samplesTo = new HashSet <StoryboardSoundSample>(beatmapTo.StoryboardSoundSamples);
var mode = (GameMode)beatmapTo.General["Mode"].Value;
foreach (var sampleFrom in beatmapFrom.StoryboardSoundSamples)
{
if (ignoreHssbSamples)
{
var tloHere = processedTimeline.TimelineObjects.FindAll(o =>
Math.Abs(o.Time - sampleFrom.Time) <= 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 = beatmapTo.StoryboardSoundSamples.OrderBy(o => o.Time).ToList();
}
if (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();
// Update progressbar
if (worker != null && worker.WorkerReportsProgress)
{
worker.ReportProgress(++mapsDone * 100 / paths.Length);
}
}
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;
bool editorRead = EditorReaderStuff.TryGetFullEditorReader(out var reader);
foreach (string path in vm.MapPaths)
{
var editor = EditorReaderStuff.GetBeatmapEditor(path, reader, editorRead);
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);
}
}
TimingPointsChange.ApplyChanges(beatmap.BeatmapTiming, timingPointsChanges);
// Save the file
editor.SaveFile();
}
return("Done!");
}
private string Complete_Sliders(Arguments arg, BackgroundWorker worker, DoWorkEventArgs _)
{
int slidersCompleted = 0;
bool editorRead = EditorReaderStuff.TryGetFullEditorReader(out var reader);
foreach (string path in arg.Paths)
{
var editor = EditorReaderStuff.GetBeatmapEditor(path, reader, editorRead, out var selected, out var editorActuallyRead);
if (arg.SelectionMode == 0 && !editorActuallyRead)
{
return(EditorReaderStuff.SelectedObjectsReadFailText);
}
Beatmap beatmap = editor.Beatmap;
Timing timing = beatmap.BeatmapTiming;
List <HitObject> markedObjects = arg.SelectionMode == 0 ? selected :
arg.SelectionMode == 1 ? beatmap.GetBookmarkedObjects() :
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));
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, editorRead));
}
// 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 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 editorRead = EditorReaderStuff.TryGetFullEditorReader(out var reader);
foreach (var path in paths)
{
var editor = EditorReaderStuff.GetBeatmapEditor(path, reader, editorRead);
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 metadata to {mapsDone} {(mapsDone == 1 ? "beatmap" : "beatmaps")}!";
return(message);
}
private string Copy_Timing(TimingCopierVM arg, BackgroundWorker worker, DoWorkEventArgs _)
{
string[] paths = arg.ExportPath.Split('|');
int mapsDone = 0;
bool editorRead = EditorReaderStuff.TryGetFullEditorReader(out var reader);
foreach (string exportPath in paths)
{
var editorTo = EditorReaderStuff.GetBeatmapEditor(exportPath, reader, editorRead);
var editorFrom = EditorReaderStuff.GetBeatmapEditor(arg.ImportPath, reader, editorRead);
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);
}