public Timeline(List <HitObject> hitObjects, Timing timing) { // Convert all the HitObjects to TimeLineObjects TimeLineObjects = new List <TimelineObject>(); foreach (HitObject ho in hitObjects) { ho.TimelineObjects = new List <TimelineObject>(); if (ho.IsCircle) { TimeLineObjects.Add(new TimelineObject(ho, ho.Time, ho.ObjectType, 0, ho.Hitsounds, ho.SampleSet, ho.AdditionSet)); ho.TimelineObjects.Add(TimeLineObjects.Last()); } else if (ho.IsSlider) { // Adding TimeLineObject for every repeat of the slider double sliderTemporalLength = timing.CalculateSliderTemporalLength(ho.Time, ho.PixelLength); for (int i = 0; i <= ho.Repeat; i++) { double time = Math.Floor(ho.Time + sliderTemporalLength * i); TimeLineObjects.Add(new TimelineObject(ho, time, ho.ObjectType, i, ho.EdgeHitsounds[i], ho.EdgeSampleSets[i], ho.EdgeAdditionSets[i])); ho.TimelineObjects.Add(TimeLineObjects.Last()); } } else if (ho.IsSpinner) // Only the end has hitsounds { TimeLineObjects.Add(new TimelineObject(ho, ho.Time, ho.ObjectType, 0, 0, 0, 0)); ho.TimelineObjects.Add(TimeLineObjects.Last()); TimeLineObjects.Add(new TimelineObject(ho, ho.EndTime, ho.ObjectType, 1, ho.Hitsounds, ho.SampleSet, ho.AdditionSet)); ho.TimelineObjects.Add(TimeLineObjects.Last()); } else // Hold note. Only start has hitsounds { TimeLineObjects.Add(new TimelineObject(ho, ho.Time, ho.ObjectType, 0, ho.Hitsounds, ho.SampleSet, ho.AdditionSet)); ho.TimelineObjects.Add(TimeLineObjects.Last()); TimeLineObjects.Add(new TimelineObject(ho, ho.EndTime, ho.ObjectType, 1, 0, 0, 0)); ho.TimelineObjects.Add(TimeLineObjects.Last()); } } // Sort the TimeLineObjects by their time TimeLineObjects = TimeLineObjects.OrderBy(o => o.Time).ToList(); }
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> /// Does a procedure similar to <see cref="MapCleaner"/> which adjusts the pattern so it fits in the beatmap. /// It does so according to the options selected in this. /// </summary> /// <param name="patternBeatmap"></param> /// <param name="beatmap"></param> /// <param name="parts"></param> /// <param name="timingPointsChanges"></param> private void PreparePattern(Beatmap patternBeatmap, Beatmap beatmap, out List <Part> parts, out List <TimingPointsChange> timingPointsChanges) { double patternStartTime = patternBeatmap.GetHitObjectStartTime(); Timing originalTiming = beatmap.BeatmapTiming; Timing patternTiming = patternBeatmap.BeatmapTiming; GameMode targetMode = (GameMode)beatmap.General["Mode"].IntValue; double originalCircleSize = beatmap.Difficulty["CircleSize"].DoubleValue; double patternCircleSize = patternBeatmap.Difficulty["CircleSize"].DoubleValue; double originalTickRate = beatmap.Difficulty["SliderTickRate"].DoubleValue; double patternTickRate = patternBeatmap.Difficulty["SliderTickRate"].DoubleValue; // Don't include SV changes if it is based on nothing bool includePatternSliderVelocity = patternTiming.Count > 0; // Avoid including hitsounds if there are no timingpoints to get hitsounds from bool includeTimingPointHitsounds = IncludeHitsounds && patternTiming.Count > 0; // Don't scale to new timing if the pattern has no timing to speak of bool scaleToNewTiming = ScaleToNewTiming && patternTiming.Redlines.Count > 0; // Avoid overwriting timing if the pattern has no redlines TimingOverwriteMode timingOverwriteMode = patternTiming.Redlines.Count > 0 ? TimingOverwriteMode : TimingOverwriteMode.OriginalTimingOnly; // Get the scale for custom scale x CS scale double csScale = Beatmap.GetHitObjectRadius(originalCircleSize) / Beatmap.GetHitObjectRadius(patternCircleSize); double spatialScale = ScaleToNewCircleSize && !double.IsNaN(csScale) ? CustomScale * csScale : CustomScale; // Get a BPM multiplier to fix the tick rate // This multiplier is not meant to change SV so this is subtracted from the greenline SV later double bpmMultiplier = FixTickRate ? patternTickRate / originalTickRate : 1; // Dont give new combo to all hit objects which were actually new combo in the pattern, // because it leads to unexpected NC's at the start of patterns. // Collect Kiai toggles List <TimingPoint> kiaiToggles = new List <TimingPoint>(); bool lastKiai = false; // If not including the kiai of the pattern, add the kiai of the original map. // This has to be done because this part of the original map might get deleted. foreach (TimingPoint tp in IncludeKiai ? patternTiming.TimingPoints : originalTiming.TimingPoints) { if (tp.Kiai != lastKiai || kiaiToggles.Count == 0) { kiaiToggles.Add(tp.Copy()); lastKiai = tp.Kiai; } } // Collect SliderVelocity changes for mania/taiko List <TimingPoint> svChanges = new List <TimingPoint>(); double lastSV = -100; // If not including the SV of the pattern, add the SV of the original map. // This has to be done because this part of the original map might get deleted. foreach (TimingPoint tp in includePatternSliderVelocity ? patternTiming.TimingPoints : originalTiming.TimingPoints) { if (tp.Uninherited) { lastSV = -100; } else { if (Math.Abs(tp.MpB - lastSV) > Precision.DOUBLE_EPSILON) { svChanges.Add(tp.Copy()); lastSV = tp.MpB; } } } // If not including the SV of the pattern, set the SV of sliders to that of the original beatmap, // so the pattern will take over the SV of the original beatmap. if (!includePatternSliderVelocity) { foreach (var ho in patternBeatmap.HitObjects.Where(ho => ho.IsSlider)) { ho.SliderVelocity = originalTiming.GetSvAtTime(ho.Time); } } // Get the timeline before moving all objects so it has the correct hitsounds // Make sure that moving the objects in the pattern moves the timeline objects aswell // This method is NOT safe to use in beat time Timeline patternTimeline = patternBeatmap.GetTimeline(); Timing transformOriginalTiming = originalTiming; Timing transformPatternTiming = patternTiming; if (scaleToNewTiming) { // Transform everything to beat time relative to pattern start time foreach (var ho in patternBeatmap.HitObjects) { double oldEndTime = ho.GetEndTime(false); ho.Time = patternTiming.GetBeatLength(patternStartTime, ho.Time); ho.EndTime = patternTiming.GetBeatLength(patternStartTime, oldEndTime); // The body hitsounds are not copies of timingpoints in patternTiming so they should be copied before changing offset for (int i = 0; i < ho.BodyHitsounds.Count; i++) { TimingPoint tp = ho.BodyHitsounds[i].Copy(); tp.Offset = patternTiming.GetBeatLength(patternStartTime, tp.Offset); ho.BodyHitsounds[i] = tp; } } foreach (var tp in kiaiToggles.Concat(svChanges)) { tp.Offset = patternTiming.GetBeatLength(patternStartTime, tp.Offset); } // Transform the pattern redlines to beat time // This will not change the order of redlines (unless negative BPM exists) transformPatternTiming = patternTiming.Copy(); foreach (var tp in transformPatternTiming.Redlines) { tp.Offset = patternTiming.GetBeatLength(patternStartTime, tp.Offset); } // Transform the original timingpoints to beat time // This will not change the order of timingpoints (unless negative BPM exists) transformOriginalTiming = originalTiming.Copy(); foreach (var tp in transformOriginalTiming.TimingPoints) { tp.Offset = originalTiming.GetBeatLength(patternStartTime, tp.Offset); } } // Fix SV for the new global SV var globalSvFactor = transformOriginalTiming.SliderMultiplier / transformPatternTiming.SliderMultiplier; if (FixGlobalSv) { foreach (HitObject ho in patternBeatmap.HitObjects.Where(o => o.IsSlider)) { ho.SliderVelocity *= globalSvFactor; } foreach (TimingPoint tp in svChanges) { tp.MpB *= globalSvFactor; } } else { foreach (HitObject ho in patternBeatmap.HitObjects.Where(o => o.IsSlider)) { ho.TemporalLength /= globalSvFactor; } } // Partition the pattern based on the timing in the pattern if (PatternOverwriteMode == PatternOverwriteMode.PartitionedOverwrite) { parts = PartitionBeatmap(patternBeatmap, scaleToNewTiming); } else { parts = new List <Part> { new Part(patternBeatmap.HitObjects[0].Time, patternBeatmap.HitObjects[patternBeatmap.HitObjects.Count - 1].Time, patternBeatmap.HitObjects) }; } // Construct a new timing which is a mix of the beatmap and the pattern. // If scaleToNewTiming then use beat relative values to determine the duration of timing sections in the pattern. // scaleToNewTiming must scale all the partitions, timingpoints, hitobjects, and events (if applicable). Timing newTiming = new Timing(transformOriginalTiming.SliderMultiplier); var lastEndTime = double.NegativeInfinity; foreach (var part in parts) { var startTime = part.StartTime; var endTime = part.EndTime; // Subtract one to omit BPM changes right on the end of the part. // Add the redlines in between patterns newTiming.AddRange(transformOriginalTiming.GetRedlinesInRange(lastEndTime, startTime, false)); var startOriginalRedline = transformOriginalTiming.GetRedlineAtTime(startTime); // Minus 1 the offset so its possible to have a custom BPM redline right on the start time if you have // the default BPM redline before it. var patternDefaultMpb = transformPatternTiming.GetMpBAtTime(startTime - 2 * Precision.DOUBLE_EPSILON); TimingPoint[] inPartRedlines; TimingPoint startPartRedline; switch (timingOverwriteMode) { case TimingOverwriteMode.PatternTimingOnly: // Subtract one from the end time to omit BPM changes right on the end of the part. inPartRedlines = transformPatternTiming.GetRedlinesInRange(startTime, Math.Max(startTime, endTime - 2 * Precision.DOUBLE_EPSILON)).ToArray(); startPartRedline = transformPatternTiming.GetRedlineAtTime(startTime); break; case TimingOverwriteMode.InPatternAbsoluteTiming: var tempInPartRedlines = transformPatternTiming.GetRedlinesInRange(startTime, endTime - 2 * Precision.DOUBLE_EPSILON); // Replace all parts in the pattern which have the default BPM to timing from the target beatmap. inPartRedlines = tempInPartRedlines.Select(tp => { if (Precision.AlmostEquals(tp.MpB, patternDefaultMpb)) { var tp2 = transformOriginalTiming.GetRedlineAtTime(tp.Offset).Copy(); tp2.Offset = tp2.Offset; return(tp2); } return(tp); }).ToArray(); startPartRedline = startOriginalRedline; break; case TimingOverwriteMode.InPatternRelativeTiming: // Multiply mix the pattern timing and the original timing together. // The pattern timing divided by the default BPM will be used as a scalar for the original timing. var tempInPartRedlines2 = transformPatternTiming.GetRedlinesInRange(startTime, endTime - 2 * Precision.DOUBLE_EPSILON); var tempInOriginalRedlines = transformOriginalTiming.GetRedlinesInRange(startTime, endTime - 2 * Precision.DOUBLE_EPSILON); // Replace all parts in the pattern which have the default BPM to timing from the target beatmap. inPartRedlines = tempInPartRedlines2.Select(tp => { var tp2 = tp.Copy(); tp2.MpB *= transformOriginalTiming.GetMpBAtTime(tp.Offset) / patternDefaultMpb; return(tp2); }).Concat(tempInOriginalRedlines.Select(tp => { var tp2 = tp.Copy(); tp2.MpB *= transformPatternTiming.GetMpBAtTime(tp.Offset) / patternDefaultMpb; return(tp2); })).ToArray(); startPartRedline = transformPatternTiming.GetRedlineAtTime(startTime).Copy(); startPartRedline.MpB *= transformOriginalTiming.GetMpBAtTime(startTime) / patternDefaultMpb; break; default: // Original timing only // Subtract one from the end time to omit BPM changes right on the end of the part. inPartRedlines = transformOriginalTiming.GetRedlinesInRange(startTime, Math.Max(startTime, endTime - 2 * Precision.DOUBLE_EPSILON)).ToArray(); startPartRedline = transformOriginalTiming.GetRedlineAtTime(startTime); break; } // Add the redlines for inside the part newTiming.AddRange(inPartRedlines); // If the pattern starts with different BPM than the map add an extra redline at the start of the pattern // to make sure it the pattern starts out at the right BPM as we only copy the timingpoints during the pattern itself // and the redline may be way before that. // This will probably only do something on the PatternTimingOnly mode as the other modes make sure // the BPM at the start of the pattern will be the same as the original beatmap anyways. if (Math.Abs(startPartRedline.MpB * bpmMultiplier - startOriginalRedline.MpB) > Precision.DOUBLE_EPSILON) { // We dont have to add the redline again if its already during the pattern. if (Math.Abs(startPartRedline.Offset - startTime) > Precision.DOUBLE_EPSILON) { var copy = startPartRedline.Copy(); copy.Offset = startTime; newTiming.Add(copy); } } // Fix SV for the new BPM, so the SV effect of the new BPM is cancelled if (FixBpmSv) { if (scaleToNewTiming) { foreach (HitObject ho in patternBeatmap.HitObjects.Where(o => o.IsSlider)) { var bpmSvFactor = SnapToNewTiming ? transformPatternTiming.GetMpBAtTime(ho.Time) / newTiming.GetMpBAtTime(newTiming.ResnapBeatTime(ho.Time, BeatDivisors)) : transformPatternTiming.GetMpBAtTime(ho.Time) / newTiming.GetMpBAtTime(ho.Time); ho.SliderVelocity *= bpmSvFactor; } } else { foreach (HitObject ho in patternBeatmap.HitObjects.Where(o => o.IsSlider)) { var bpmSvFactor = SnapToNewTiming ? transformPatternTiming.GetMpBAtTime(ho.Time) / newTiming.GetMpBAtTime(newTiming.Resnap(ho.Time, BeatDivisors)) : transformPatternTiming.GetMpBAtTime(ho.Time) / newTiming.GetMpBAtTime(ho.Time); ho.SliderVelocity *= bpmSvFactor; } } } // Recalculate temporal length and re-assign redline for the sliderend resnapping later foreach (var ho in part.HitObjects) { ho.UnInheritedTimingPoint = newTiming.GetRedlineAtTime(ho.Time); if (ho.IsSlider) { // If scaleToNewTiming then the end time is already at the correct beat time // The SV has to be adjusted so the sliderend is really on the end time if (scaleToNewTiming) { var wantedMsDuration = (newTiming.GetMilliseconds(ho.GetEndTime(false), patternStartTime) - newTiming.GetMilliseconds(ho.Time, patternStartTime)) / ho.Repeat; var trueMsDuration = newTiming.CalculateSliderTemporalLength(SnapToNewTiming ? newTiming.ResnapBeatTime(ho.Time, BeatDivisors) : ho.Time, ho.PixelLength, ho.SliderVelocity); ho.SliderVelocity /= trueMsDuration / wantedMsDuration; } else { ho.TemporalLength = newTiming.CalculateSliderTemporalLength(SnapToNewTiming ? newTiming.Resnap(ho.Time, BeatDivisors) : ho.Time, ho.PixelLength, ho.SliderVelocity); } } } // Update the end time because the lengths of sliders changed endTime = part.HitObjects.Max(o => o.GetEndTime(!scaleToNewTiming)); part.EndTime = endTime; // Add a redline at the end of the pattern to make sure the BPM goes back to normal after the pattern. var endOriginalRedline = transformOriginalTiming.GetRedlineAtTime(endTime); var endPartRedline = inPartRedlines.LastOrDefault() ?? startPartRedline; if (Math.Abs(endPartRedline.MpB * bpmMultiplier - endOriginalRedline.MpB) > Precision.DOUBLE_EPSILON) { // We dont have to add the redline again if its already during the parts in between parts. if (Math.Abs(endOriginalRedline.Offset - endTime) > Precision.DOUBLE_EPSILON) { var copy = endOriginalRedline.Copy(); copy.Offset = endTime; newTiming.Add(copy); } } lastEndTime = endTime; } // Transform the beat time back to millisecond time Timing transformNewTiming = newTiming; if (scaleToNewTiming) { // Transform back the timing transformNewTiming = newTiming.Copy(); foreach (var tp in transformNewTiming.TimingPoints) { tp.Offset = Math.Floor(newTiming.GetMilliseconds(tp.Offset, patternStartTime) + Precision.DOUBLE_EPSILON); } // Transform back the parts foreach (Part part in parts) { part.StartTime = Math.Floor(newTiming.GetMilliseconds(part.StartTime, patternStartTime)); part.EndTime = Math.Floor(newTiming.GetMilliseconds(part.EndTime, patternStartTime)); } // Transform everything to millisecond time relative to pattern start time foreach (var ho in patternBeatmap.HitObjects) { // Calculate the millisecond end time before changing the start time because the end time getter uses the beat time start time var msEndTime = newTiming.GetMilliseconds(ho.GetEndTime(false), patternStartTime); ho.Time = newTiming.GetMilliseconds(ho.Time, patternStartTime); // End time has to be set after the time because the end time setter uses the millisecond start time ho.EndTime = msEndTime; foreach (var tp in ho.BodyHitsounds) { tp.Offset = newTiming.GetMilliseconds(tp.Offset, patternStartTime); } // It is necessary to resnap early so it can recalculate the duration using the right offset if (SnapToNewTiming) { ho.ResnapSelf(transformNewTiming, BeatDivisors); } if (ho.IsSlider) { ho.CalculateSliderTemporalLength(transformNewTiming, true); } ho.UnInheritedTimingPoint = transformNewTiming.GetRedlineAtTime(ho.Time); ho.UpdateTimelineObjectTimes(); } foreach (var tp in kiaiToggles.Concat(svChanges)) { tp.Offset = Math.Floor(newTiming.GetMilliseconds(tp.Offset, patternStartTime)); } } // Apply custom scale and rotate if (Math.Abs(spatialScale - 1) > Precision.DOUBLE_EPSILON || Math.Abs(CustomRotate) > Precision.DOUBLE_EPSILON) { // Create a transformation matrix for the custom scale and rotate // The rotation is inverted because the default osu! rotation goes clockwise Matrix2 transform = Matrix2.Mult(Matrix2.CreateScale(spatialScale), Matrix2.CreateRotation(-CustomRotate)); Vector2 centre = new Vector2(256, 192); foreach (var ho in patternBeatmap.HitObjects) { ho.Move(-centre); ho.Transform(transform); ho.Move(centre); // Scale pixel length and SV for sliders aswell if (ho.IsSlider) { ho.PixelLength *= spatialScale; ho.SliderVelocity /= spatialScale; } } // osu! clips coordinates to the bounds (0,512), so there is some space downwards to still place the pattern // Calculate the new bounds of the pattern and try to place it in the playfield var minX = patternBeatmap.HitObjects.Min(o => o.Pos.X); var minY = patternBeatmap.HitObjects.Min(o => o.Pos.Y); Vector2 offset = new Vector2(Math.Max(-minX, 0), Math.Max(-minY, 0)); if (offset.LengthSquared > 0) { foreach (var ho in patternBeatmap.HitObjects) { ho.Move(offset); } } } // Manualify stacks if (FixStackLeniency) { // If scale to new timing was used update the circle size of the pattern, // so it calculates stacks at the new size of the pattern. if (ScaleToNewCircleSize) { patternBeatmap.Difficulty["CircleSize"].DoubleValue = originalCircleSize; } patternBeatmap.CalculateEndPositions(); patternBeatmap.UpdateStacking(rounded: true); // Manualify by setting the base position to the stacked position foreach (var ho in patternBeatmap.HitObjects) { var offset = ho.StackedPos - ho.Pos; ho.Move(offset); } } // Resnap everything to the new timing. if (SnapToNewTiming) { // Resnap all objects foreach (HitObject ho in patternBeatmap.HitObjects) { ho.ResnapSelf(transformNewTiming, BeatDivisors); ho.ResnapEnd(transformNewTiming, BeatDivisors); ho.ResnapPosition(targetMode, patternCircleSize); // Resnap to column X positions for mania only } // Resnap Kiai toggles foreach (TimingPoint tp in kiaiToggles) { tp.ResnapSelf(transformNewTiming, BeatDivisors); } // Resnap SliderVelocity changes foreach (TimingPoint tp in svChanges) { tp.ResnapSelf(transformNewTiming, BeatDivisors); } } // Multiply BPM and divide SV foreach (var part in parts) { foreach (var tp in transformNewTiming.GetRedlinesInRange(part.StartTime - 2 * Precision.DOUBLE_EPSILON, part.EndTime, false)) { tp.MpB /= bpmMultiplier; // MpB is the inverse of the BPM } foreach (var ho in part.HitObjects) { ho.SliderVelocity *= bpmMultiplier; // SliderVelocity is the inverse of the multiplier } } // Make new timingpoints changes for the hitsounds and other stuff // Add redlines timingPointsChanges = transformNewTiming.Redlines.Select(tp => new TimingPointsChange(tp, mpb: true, meter: true, unInherited: true, omitFirstBarLine: true, fuzzyness: Precision.DOUBLE_EPSILON)).ToList(); // Add SliderVelocity changes for taiko and mania if (includePatternSliderVelocity && (targetMode == GameMode.Taiko || targetMode == GameMode.Mania)) { timingPointsChanges.AddRange(svChanges.Select(tp => new TimingPointsChange(tp, mpb: true, fuzzyness: 0.4))); } // Add Kiai toggles timingPointsChanges.AddRange(kiaiToggles.Select(tp => new TimingPointsChange(tp, kiai: true))); // Add Hitobject stuff foreach (HitObject ho in patternBeatmap.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, fuzzyness: 0.4)); } if (!IncludeHitsounds) { // Remove hitsounds and skip adding body hitsounds ho.ResetHitsounds(); continue; } if (includeTimingPointHitsounds) { // Body hitsounds bool vol = ho.IsSlider || ho.IsSpinner; bool sam = ho.IsSlider && ho.SampleSet == 0; bool ind = ho.IsSlider; timingPointsChanges.AddRange(ho.BodyHitsounds.Select(tp => new TimingPointsChange(tp, volume: vol, index: ind, sampleset: sam))); } } // Add timeline hitsounds if (includeTimingPointHitsounds) { foreach (TimelineObject tlo in patternTimeline.TimelineObjects) { if (tlo.HasHitsound) { // Add greenlines for hitsounds TimingPoint tp = tlo.HitsoundTimingPoint.Copy(); tp.Offset = tlo.Time; timingPointsChanges.Add(new TimingPointsChange(tp, sampleset: true, volume: true, index: true)); } } } // Replace the old timingpoints patternTiming.Clear(); TimingPointsChange.ApplyChanges(patternTiming, timingPointsChanges); patternBeatmap.GiveObjectsGreenlines(); patternBeatmap.CalculateSliderEndTimes(); }
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(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); }