Refactor distance snapping to be handled by HitObjectComposer (#6599)

Refactor distance snapping to be handled by HitObjectComposer

Co-authored-by: Dean Herbert <pe@ppy.sh>

osu.Game.Rulesets.Osu.Tests/TestSceneOsuDistanceSnapGrid.cs

@@ -11,6 +11,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Framework.MathUtils;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Edit;
 using osu.Game.Rulesets.Osu.Objects;
@@ -38,26 +39,34 @@ namespace osu.Game.Rulesets.Osu.Tests
         [Cached]
         private readonly BindableBeatDivisor beatDivisor = new BindableBeatDivisor();
 
-        private TestOsuDistanceSnapGrid grid;
+        [Cached(typeof(IDistanceSnapProvider))]
+        private readonly SnapProvider snapProvider = new SnapProvider();
+
+        private readonly TestOsuDistanceSnapGrid grid;
 
         public TestSceneOsuDistanceSnapGrid()
         {
             editorBeatmap = new EditorBeatmap<OsuHitObject>(new OsuBeatmap());
 
-            createGrid();
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.SlateGray
+                },
+                grid = new TestOsuDistanceSnapGrid(new HitCircle { Position = grid_position }),
+                new SnappingCursorContainer { GetSnapPosition = v => grid.GetSnappedPosition(grid.ToLocalSpace(v)).position }
+            };
         }
 
         [SetUp]
         public void Setup() => Schedule(() =>
         {
-            Clear();
-
             editorBeatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = 1;
             editorBeatmap.ControlPointInfo.DifficultyPoints.Clear();
             editorBeatmap.ControlPointInfo.TimingPoints.Clear();
             editorBeatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { BeatLength = beat_length });
-
-            beatDivisor.Value = 1;
         });
 
         [TestCase(1)]
@@ -71,53 +80,11 @@ namespace osu.Game.Rulesets.Osu.Tests
         public void TestBeatDivisor(int divisor)
         {
             AddStep($"set beat divisor = {divisor}", () => beatDivisor.Value = divisor);
-            createGrid();
-        }
-
-        [TestCase(100, 100)]
-        [TestCase(200, 100)]
-        public void TestBeatLength(float beatLength, float expectedSpacing)
-        {
-            AddStep($"set beat length = {beatLength}", () =>
-            {
-                editorBeatmap.ControlPointInfo.TimingPoints.Clear();
-                editorBeatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { BeatLength = beatLength });
-            });
-
-            createGrid();
-            AddAssert($"spacing = {expectedSpacing}", () => Precision.AlmostEquals(expectedSpacing, grid.DistanceSpacing));
-        }
-
-        [TestCase(0.5f, 50)]
-        [TestCase(1, 100)]
-        [TestCase(1.5f, 150)]
-        public void TestSpeedMultiplier(float multiplier, float expectedSpacing)
-        {
-            AddStep($"set speed multiplier = {multiplier}", () =>
-            {
-                editorBeatmap.ControlPointInfo.DifficultyPoints.Clear();
-                editorBeatmap.ControlPointInfo.DifficultyPoints.Add(new DifficultyControlPoint { SpeedMultiplier = multiplier });
-            });
-
-            createGrid();
-            AddAssert($"spacing = {expectedSpacing}", () => Precision.AlmostEquals(expectedSpacing, grid.DistanceSpacing));
-        }
-
-        [TestCase(0.5f, 50)]
-        [TestCase(1, 100)]
-        [TestCase(1.5f, 150)]
-        public void TestSliderMultiplier(float multiplier, float expectedSpacing)
-        {
-            AddStep($"set speed multiplier = {multiplier}", () => editorBeatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = multiplier);
-            createGrid();
-            AddAssert($"spacing = {expectedSpacing}", () => Precision.AlmostEquals(expectedSpacing, grid.DistanceSpacing));
         }
 
         [Test]
         public void TestCursorInCentre()
         {
-            createGrid();
-
             AddStep("move mouse to centre", () => InputManager.MoveMouseTo(grid.ToScreenSpace(grid_position)));
             assertSnappedDistance((float)beat_length);
         }
@@ -125,8 +92,6 @@ namespace osu.Game.Rulesets.Osu.Tests
         [Test]
         public void TestCursorBeforeMovementPoint()
         {
-            createGrid();
-
             AddStep("move mouse to just before movement point", () => InputManager.MoveMouseTo(grid.ToScreenSpace(grid_position + new Vector2((float)beat_length, 0) * 1.49f)));
             assertSnappedDistance((float)beat_length);
         }
@@ -134,37 +99,17 @@ namespace osu.Game.Rulesets.Osu.Tests
         [Test]
         public void TestCursorAfterMovementPoint()
         {
-            createGrid();
-
             AddStep("move mouse to just after movement point", () => InputManager.MoveMouseTo(grid.ToScreenSpace(grid_position + new Vector2((float)beat_length, 0) * 1.51f)));
             assertSnappedDistance((float)beat_length * 2);
         }
 
         private void assertSnappedDistance(float expectedDistance) => AddAssert($"snap distance = {expectedDistance}", () =>
         {
-            Vector2 snappedPosition = grid.GetSnapPosition(grid.ToLocalSpace(InputManager.CurrentState.Mouse.Position));
+            Vector2 snappedPosition = grid.GetSnappedPosition(grid.ToLocalSpace(InputManager.CurrentState.Mouse.Position)).position;
-            float distance = Vector2.Distance(snappedPosition, grid_position);
 
-            return Precision.AlmostEquals(expectedDistance, distance);
+            return Precision.AlmostEquals(expectedDistance, Vector2.Distance(snappedPosition, grid_position));
         });
 
-        private void createGrid()
-        {
-            AddStep("create grid", () =>
-            {
-                Children = new Drawable[]
-                {
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = Color4.SlateGray
-                    },
-                    grid = new TestOsuDistanceSnapGrid(new HitCircle { Position = grid_position }),
-                    new SnappingCursorContainer { GetSnapPosition = v => grid.GetSnapPosition(grid.ToLocalSpace(v)) }
-                };
-            });
-        }
-
         private class SnappingCursorContainer : CompositeDrawable
         {
             public Func<Vector2, Vector2> GetSnapPosition;
@@ -213,5 +158,20 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
             }
         }
+
+        private class SnapProvider : IDistanceSnapProvider
+        {
+            public (Vector2 position, double time) GetSnappedPosition(Vector2 position, double time) => (position, time);
+
+            public float GetBeatSnapDistanceAt(double referenceTime) => (float)beat_length;
+
+            public float DurationToDistance(double referenceTime, double duration) => 0;
+
+            public double DistanceToDuration(double referenceTime, float distance) => 0;
+
+            public double GetSnappedDurationFromDistance(double referenceTime, float distance) => 0;
+
+            public float GetSnappedDistanceFromDistance(double referenceTime, float distance) => 0;
+        }
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs

@@ -1,6 +1,7 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -8,7 +9,6 @@ using osu.Framework.Graphics.Lines;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
 using osuTK;
 
@@ -16,6 +16,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
     public class PathControlPointPiece : BlueprintPiece<Slider>
     {
+        public Action<Vector2[]> ControlPointsChanged;
+
         private readonly Slider slider;
         private readonly int index;
 
@@ -96,7 +98,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             if (isSegmentSeparatorWithPrevious)
                 newControlPoints[index - 1] = newControlPoints[index];
 
-            slider.Path = new SliderPath(slider.Path.Type, newControlPoints);
+            ControlPointsChanged?.Invoke(newControlPoints);
 
             return true;
         }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs

@@ -1,14 +1,18 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
     public class PathControlPointVisualiser : CompositeDrawable
     {
+        public Action<Vector2[]> ControlPointsChanged;
+
         private readonly Slider slider;
 
         private readonly Container<PathControlPointPiece> pieces;
@@ -25,7 +29,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             base.Update();
 
             while (slider.Path.ControlPoints.Length > pieces.Count)
-                pieces.Add(new PathControlPointPiece(slider, pieces.Count));
+                pieces.Add(new PathControlPointPiece(slider, pieces.Count) { ControlPointsChanged = c => ControlPointsChanged?.Invoke(c) });
             while (slider.Path.ControlPoints.Length < pieces.Count)
                 pieces.Remove(pieces[pieces.Count - 1]);
         }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs

@@ -33,6 +33,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         private PlacementState state;
 
+        [Resolved(CanBeNull = true)]
+        private HitObjectComposer composer { get; set; }
+
         public SliderPlacementBlueprint()
             : base(new Objects.Slider())
         {
@@ -48,7 +51,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 bodyPiece = new SliderBodyPiece(),
                 headCirclePiece = new HitCirclePiece(),
                 tailCirclePiece = new HitCirclePiece(),
-                new PathControlPointVisualiser(HitObject),
+                new PathControlPointVisualiser(HitObject) { ControlPointsChanged = _ => updateSlider() },
             };
 
             setState(PlacementState.Initial);
@@ -131,8 +134,12 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
         private void updateSlider()
         {
-            var newControlPoints = segments.SelectMany(s => s.ControlPoints).Concat(cursor.Yield()).ToArray();
+            Vector2[] newControlPoints = segments.SelectMany(s => s.ControlPoints).Concat(cursor.Yield()).ToArray();
-            HitObject.Path = new SliderPath(newControlPoints.Length > 2 ? PathType.Bezier : PathType.Linear, newControlPoints);
+
+            var unsnappedPath = new SliderPath(newControlPoints.Length > 2 ? PathType.Bezier : PathType.Linear, newControlPoints);
+            var snappedDistance = composer?.GetSnappedDistanceFromDistance(HitObject.StartTime, (float)unsnappedPath.Distance) ?? (float)unsnappedPath.Distance;
+
+            HitObject.Path = new SliderPath(unsnappedPath.Type, newControlPoints, snappedDistance);
 
             bodyPiece.UpdateFrom(HitObject);
             headCirclePiece.UpdateFrom(HitObject.HeadCircle);

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs

@@ -1,7 +1,11 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
@@ -15,6 +19,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         protected readonly SliderCircleSelectionBlueprint HeadBlueprint;
         protected readonly SliderCircleSelectionBlueprint TailBlueprint;
 
+        [Resolved(CanBeNull = true)]
+        private HitObjectComposer composer { get; set; }
+
         public SliderSelectionBlueprint(DrawableSlider slider)
             : base(slider)
         {
@@ -25,7 +32,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 BodyPiece = new SliderBodyPiece(),
                 HeadBlueprint = CreateCircleSelectionBlueprint(slider, SliderPosition.Start),
                 TailBlueprint = CreateCircleSelectionBlueprint(slider, SliderPosition.End),
-                new PathControlPointVisualiser(sliderObject),
+                new PathControlPointVisualiser(sliderObject) { ControlPointsChanged = onNewControlPoints },
             };
         }
 
@@ -36,6 +43,14 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             BodyPiece.UpdateFrom(HitObject);
         }
 
+        private void onNewControlPoints(Vector2[] controlPoints)
+        {
+            var unsnappedPath = new SliderPath(controlPoints.Length > 2 ? PathType.Bezier : PathType.Linear, controlPoints);
+            var snappedDistance = composer?.GetSnappedDistanceFromDistance(HitObject.StartTime, (float)unsnappedPath.Distance) ?? (float)unsnappedPath.Distance;
+
+            HitObject.Path = new SliderPath(unsnappedPath.Type, controlPoints, snappedDistance);
+        }
+
         public override Vector2 SelectionPoint => HeadBlueprint.SelectionPoint;
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => BodyPiece.ReceivePositionalInputAt(screenSpacePos);

osu.Game.Rulesets.Osu/Edit/OsuDistanceSnapGrid.cs

@@ -1,8 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit.Compose.Components;
 
@@ -15,15 +13,5 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
             Masking = true;
         }
-
-        protected override float GetVelocity(double time, ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
-        {
-            TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(time);
-            DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(time);
-
-            double scoringDistance = OsuHitObject.BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier;
-
-            return (float)(scoringDistance / timingPoint.BeatLength);
-        }
     }
 }

osu.Game.Tests/Editor/TestSceneHitObjectComposerDistanceSnapping.cs

@@ -0,0 +1,195 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Edit;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Tests.Editor
+{
+    [HeadlessTest]
+    public class TestSceneHitObjectComposerDistanceSnapping : EditorClockTestScene
+    {
+        private TestHitObjectComposer composer;
+
+        [SetUp]
+        public void Setup() => Schedule(() =>
+        {
+            Child = composer = new TestHitObjectComposer();
+
+            BeatDivisor.Value = 1;
+
+            composer.EditorBeatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = 1;
+            composer.EditorBeatmap.ControlPointInfo.DifficultyPoints.Clear();
+            composer.EditorBeatmap.ControlPointInfo.TimingPoints.Clear();
+
+            composer.EditorBeatmap.ControlPointInfo.DifficultyPoints.Add(new DifficultyControlPoint { SpeedMultiplier = 1 });
+            composer.EditorBeatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { BeatLength = 1000 });
+        });
+
+        [TestCase(1)]
+        [TestCase(2)]
+        public void TestSliderMultiplier(float multiplier)
+        {
+            AddStep($"set multiplier = {multiplier}", () => composer.EditorBeatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = multiplier);
+
+            assertSnapDistance(100 * multiplier);
+        }
+
+        [TestCase(1)]
+        [TestCase(2)]
+        public void TestSpeedMultiplier(float multiplier)
+        {
+            AddStep($"set multiplier = {multiplier}", () =>
+            {
+                composer.EditorBeatmap.ControlPointInfo.DifficultyPoints.Clear();
+                composer.EditorBeatmap.ControlPointInfo.DifficultyPoints.Add(new DifficultyControlPoint { SpeedMultiplier = multiplier });
+            });
+
+            assertSnapDistance(100 * multiplier);
+        }
+
+        [TestCase(1)]
+        [TestCase(2)]
+        public void TestBeatDivisor(int divisor)
+        {
+            AddStep($"set divisor = {divisor}", () => BeatDivisor.Value = divisor);
+
+            assertSnapDistance(100f / divisor);
+        }
+
+        [Test]
+        public void TestConvertDurationToDistance()
+        {
+            assertDurationToDistance(500, 50);
+            assertDurationToDistance(1000, 100);
+
+            AddStep("set slider multiplier = 2", () => composer.EditorBeatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = 2);
+
+            assertDurationToDistance(500, 100);
+            assertDurationToDistance(1000, 200);
+
+            AddStep("set beat length = 500", () =>
+            {
+                composer.EditorBeatmap.ControlPointInfo.TimingPoints.Clear();
+                composer.EditorBeatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { BeatLength = 500 });
+            });
+
+            assertDurationToDistance(500, 200);
+            assertDurationToDistance(1000, 400);
+        }
+
+        [Test]
+        public void TestConvertDistanceToDuration()
+        {
+            assertDistanceToDuration(50, 500);
+            assertDistanceToDuration(100, 1000);
+
+            AddStep("set slider multiplier = 2", () => composer.EditorBeatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = 2);
+
+            assertDistanceToDuration(100, 500);
+            assertDistanceToDuration(200, 1000);
+
+            AddStep("set beat length = 500", () =>
+            {
+                composer.EditorBeatmap.ControlPointInfo.TimingPoints.Clear();
+                composer.EditorBeatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { BeatLength = 500 });
+            });
+
+            assertDistanceToDuration(200, 500);
+            assertDistanceToDuration(400, 1000);
+        }
+
+        [Test]
+        public void TestGetSnappedDurationFromDistance()
+        {
+            assertSnappedDuration(50, 0);
+            assertSnappedDuration(100, 1000);
+            assertSnappedDuration(150, 1000);
+            assertSnappedDuration(200, 2000);
+            assertSnappedDuration(250, 2000);
+
+            AddStep("set slider multiplier = 2", () => composer.EditorBeatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = 2);
+
+            assertSnappedDuration(50, 0);
+            assertSnappedDuration(100, 0);
+            assertSnappedDuration(150, 0);
+            assertSnappedDuration(200, 1000);
+            assertSnappedDuration(250, 1000);
+
+            AddStep("set beat length = 500", () =>
+            {
+                composer.EditorBeatmap.ControlPointInfo.TimingPoints.Clear();
+                composer.EditorBeatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { BeatLength = 500 });
+            });
+
+            assertSnappedDuration(50, 0);
+            assertSnappedDuration(100, 0);
+            assertSnappedDuration(150, 0);
+            assertSnappedDuration(200, 500);
+            assertSnappedDuration(250, 500);
+            assertSnappedDuration(400, 1000);
+        }
+
+        [Test]
+        public void GetSnappedDistanceFromDistance()
+        {
+            assertSnappedDistance(50, 0);
+            assertSnappedDistance(100, 100);
+            assertSnappedDistance(150, 100);
+            assertSnappedDistance(200, 200);
+            assertSnappedDistance(250, 200);
+
+            AddStep("set slider multiplier = 2", () => composer.EditorBeatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier = 2);
+
+            assertSnappedDistance(50, 0);
+            assertSnappedDistance(100, 0);
+            assertSnappedDistance(150, 0);
+            assertSnappedDistance(200, 200);
+            assertSnappedDistance(250, 200);
+
+            AddStep("set beat length = 500", () =>
+            {
+                composer.EditorBeatmap.ControlPointInfo.TimingPoints.Clear();
+                composer.EditorBeatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { BeatLength = 500 });
+            });
+
+            assertSnappedDistance(50, 0);
+            assertSnappedDistance(100, 0);
+            assertSnappedDistance(150, 0);
+            assertSnappedDistance(200, 200);
+            assertSnappedDistance(250, 200);
+            assertSnappedDistance(400, 400);
+        }
+
+        private void assertSnapDistance(float expectedDistance)
+            => AddAssert($"distance is {expectedDistance}", () => composer.GetBeatSnapDistanceAt(0) == expectedDistance);
+
+        private void assertDurationToDistance(double duration, float expectedDistance)
+            => AddAssert($"duration = {duration} -> distance = {expectedDistance}", () => composer.DurationToDistance(0, duration) == expectedDistance);
+
+        private void assertDistanceToDuration(float distance, double expectedDuration)
+            => AddAssert($"distance = {distance} -> duration = {expectedDuration}", () => composer.DistanceToDuration(0, distance) == expectedDuration);
+
+        private void assertSnappedDuration(float distance, double expectedDuration)
+            => AddAssert($"distance = {distance} -> duration = {expectedDuration} (snapped)", () => composer.GetSnappedDurationFromDistance(0, distance) == expectedDuration);
+
+        private void assertSnappedDistance(float distance, float expectedDistance)
+            => AddAssert($"distance = {distance} -> distance = {expectedDistance} (snapped)", () => composer.GetSnappedDistanceFromDistance(0, distance) == expectedDistance);
+
+        private class TestHitObjectComposer : OsuHitObjectComposer
+        {
+            public new EditorBeatmap<OsuHitObject> EditorBeatmap => base.EditorBeatmap;
+
+            public TestHitObjectComposer()
+                : base(new OsuRuleset())
+            {
+            }
+        }
+    }
+}

osu.Game.Tests/Visual/Editor/TestSceneDistanceSnapGrid.cs

@@ -1,14 +1,12 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.MathUtils;
-using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Beatmaps;
 using osu.Game.Rulesets.Osu.Objects;
@@ -27,27 +25,25 @@ namespace osu.Game.Tests.Visual.Editor
         [Cached(typeof(IEditorBeatmap))]
         private readonly EditorBeatmap<OsuHitObject> editorBeatmap;
 
-        private TestDistanceSnapGrid grid;
+        [Cached(typeof(IDistanceSnapProvider))]
+        private readonly SnapProvider snapProvider = new SnapProvider();
 
         public TestSceneDistanceSnapGrid()
         {
             editorBeatmap = new EditorBeatmap<OsuHitObject>(new OsuBeatmap());
             editorBeatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { BeatLength = beat_length });
 
-            createGrid();
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = Color4.SlateGray
+                },
+                new TestDistanceSnapGrid(new HitObject(), grid_position)
+            };
         }
 
-        [SetUp]
-        public void Setup() => Schedule(() =>
-        {
-            Clear();
-
-            editorBeatmap.ControlPointInfo.TimingPoints.Clear();
-            editorBeatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { BeatLength = beat_length });
-
-            BeatDivisor.Value = 1;
-        });
-
         [TestCase(1)]
         [TestCase(2)]
         [TestCase(3)]
@@ -56,84 +52,13 @@ namespace osu.Game.Tests.Visual.Editor
         [TestCase(8)]
         [TestCase(12)]
         [TestCase(16)]
-        public void TestInitialBeatDivisor(int divisor)
+        public void TestBeatDivisor(int divisor)
         {
             AddStep($"set beat divisor = {divisor}", () => BeatDivisor.Value = divisor);
-            createGrid();
-
-            float expectedDistance = (float)beat_length / divisor;
-            AddAssert($"spacing is {expectedDistance}", () => Precision.AlmostEquals(grid.DistanceSpacing, expectedDistance));
-        }
-
-        [Test]
-        public void TestChangeBeatDivisor()
-        {
-            createGrid();
-            AddStep("set beat divisor = 2", () => BeatDivisor.Value = 2);
-
-            const float expected_distance = (float)beat_length / 2;
-            AddAssert($"spacing is {expected_distance}", () => Precision.AlmostEquals(grid.DistanceSpacing, expected_distance));
-        }
-
-        [TestCase(100)]
-        [TestCase(200)]
-        public void TestBeatLength(double beatLength)
-        {
-            AddStep($"set beat length = {beatLength}", () =>
-            {
-                editorBeatmap.ControlPointInfo.TimingPoints.Clear();
-                editorBeatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { BeatLength = beatLength });
-            });
-
-            createGrid();
-            AddAssert($"spacing is {beatLength}", () => Precision.AlmostEquals(grid.DistanceSpacing, beatLength));
-        }
-
-        [TestCase(1)]
-        [TestCase(2)]
-        public void TestGridVelocity(float velocity)
-        {
-            createGrid(g => g.Velocity = velocity);
-
-            float expectedDistance = (float)beat_length * velocity;
-            AddAssert($"spacing is {expectedDistance}", () => Precision.AlmostEquals(grid.DistanceSpacing, expectedDistance));
-        }
-
-        [Test]
-        public void TestGetSnappedTime()
-        {
-            createGrid();
-
-            Vector2 snapPosition = Vector2.Zero;
-            AddStep("get first tick position", () => snapPosition = grid_position + new Vector2((float)beat_length, 0));
-            AddAssert("snap time is 1 beat away", () => Precision.AlmostEquals(beat_length, grid.GetSnapTime(snapPosition), 0.01));
-
-            createGrid(g => g.Velocity = 2, "with velocity = 2");
-            AddAssert("snap time is now 0.5 beats away", () => Precision.AlmostEquals(beat_length / 2, grid.GetSnapTime(snapPosition), 0.01));
-        }
-
-        private void createGrid(Action<TestDistanceSnapGrid> func = null, string description = null)
-        {
-            AddStep($"create grid {description ?? string.Empty}", () =>
-            {
-                Children = new Drawable[]
-                {
-                    new Box
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Colour = Color4.SlateGray
-                    },
-                    grid = new TestDistanceSnapGrid(new HitObject(), grid_position)
-                };
-
-                func?.Invoke(grid);
-            });
         }
 
         private class TestDistanceSnapGrid : DistanceSnapGrid
         {
-            public new float Velocity = 1;
-
             public new float DistanceSpacing => base.DistanceSpacing;
 
             public TestDistanceSnapGrid(HitObject hitObject, Vector2 centrePosition)
@@ -203,11 +128,23 @@ namespace osu.Game.Tests.Visual.Editor
                 }
             }
 
-            protected override float GetVelocity(double time, ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty)
+            public override (Vector2 position, double time) GetSnappedPosition(Vector2 screenSpacePosition)
-                => Velocity;
+                => (Vector2.Zero, 0);
+        }
 
-            public override Vector2 GetSnapPosition(Vector2 screenSpacePosition)
+        private class SnapProvider : IDistanceSnapProvider
-                => Vector2.Zero;
+        {
+            public (Vector2 position, double time) GetSnappedPosition(Vector2 position, double time) => (position, time);
+
+            public float GetBeatSnapDistanceAt(double referenceTime) => 10;
+
+            public float DurationToDistance(double referenceTime, double duration) => 0;
+
+            public double DistanceToDuration(double referenceTime, float distance) => 0;
+
+            public double GetSnappedDurationFromDistance(double referenceTime, float distance) => 0;
+
+            public float GetSnappedDistanceFromDistance(double referenceTime, float distance) => 0;
         }
     }
 }

osu.Game.Tests/Visual/Editor/TestSceneHitObjectComposer.cs

@@ -22,7 +22,7 @@ using osuTK;
 namespace osu.Game.Tests.Visual.Editor
 {
     [TestFixture]
-    public class TestSceneHitObjectComposer : OsuTestScene
+    public class TestSceneHitObjectComposer : EditorClockTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -14,6 +14,7 @@ using osu.Framework.Logging;
 using osu.Framework.Threading;
 using osu.Framework.Timing;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Configuration;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Mods;
@@ -39,6 +40,9 @@ namespace osu.Game.Rulesets.Edit
         [Resolved]
         protected IFrameBasedClock EditorClock { get; private set; }
 
+        [Resolved]
+        private BindableBeatDivisor beatDivisor { get; set; }
+
         private IWorkingBeatmap workingBeatmap;
         private Beatmap<TObject> playableBeatmap;
         private IBeatmapProcessor beatmapProcessor;
@@ -246,7 +250,7 @@ namespace osu.Game.Rulesets.Edit
         public void BeginPlacement(HitObject hitObject)
         {
             if (distanceSnapGrid != null)
-                hitObject.StartTime = GetSnappedTime(hitObject.StartTime, distanceSnapGrid.ToLocalSpace(inputManager.CurrentState.Mouse.Position));
+                hitObject.StartTime = GetSnappedPosition(distanceSnapGrid.ToLocalSpace(inputManager.CurrentState.Mouse.Position), hitObject.StartTime).time;
         }
 
         public void EndPlacement(HitObject hitObject)
@@ -257,9 +261,45 @@ namespace osu.Game.Rulesets.Edit
 
         public void Delete(HitObject hitObject) => EditorBeatmap.Remove(hitObject);
 
-        public override Vector2 GetSnappedPosition(Vector2 position) => distanceSnapGrid?.GetSnapPosition(position) ?? position;
+        public override (Vector2 position, double time) GetSnappedPosition(Vector2 position, double time) => distanceSnapGrid?.GetSnappedPosition(position) ?? (position, time);
 
-        public override double GetSnappedTime(double startTime, Vector2 position) => distanceSnapGrid?.GetSnapTime(position) ?? startTime;
+        public override float GetBeatSnapDistanceAt(double referenceTime)
+        {
+            DifficultyControlPoint difficultyPoint = EditorBeatmap.ControlPointInfo.DifficultyPointAt(referenceTime);
+            return (float)(100 * EditorBeatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier / beatDivisor.Value);
+        }
+
+        public override float DurationToDistance(double referenceTime, double duration)
+        {
+            double beatLength = EditorBeatmap.ControlPointInfo.TimingPointAt(referenceTime).BeatLength / beatDivisor.Value;
+            return (float)(duration / beatLength * GetBeatSnapDistanceAt(referenceTime));
+        }
+
+        public override double DistanceToDuration(double referenceTime, float distance)
+        {
+            double beatLength = EditorBeatmap.ControlPointInfo.TimingPointAt(referenceTime).BeatLength / beatDivisor.Value;
+            return distance / GetBeatSnapDistanceAt(referenceTime) * beatLength;
+        }
+
+        public override double GetSnappedDurationFromDistance(double referenceTime, float distance)
+            => beatSnap(referenceTime, DistanceToDuration(referenceTime, distance));
+
+        public override float GetSnappedDistanceFromDistance(double referenceTime, float distance)
+            => DurationToDistance(referenceTime, beatSnap(referenceTime, DistanceToDuration(referenceTime, distance)));
+
+        /// <summary>
+        /// Snaps a duration to the closest beat of a timing point applicable at the reference time.
+        /// </summary>
+        /// <param name="referenceTime">The time of the timing point which <paramref name="duration"/> resides in.</param>
+        /// <param name="duration">The duration to snap.</param>
+        /// <returns>A value that represents <paramref name="duration"/> snapped to the closest beat of the timing point.</returns>
+        private double beatSnap(double referenceTime, double duration)
+        {
+            double beatLength = EditorBeatmap.ControlPointInfo.TimingPointAt(referenceTime).BeatLength / beatDivisor.Value;
+
+            // A 1ms offset prevents rounding errors due to minute variations in duration
+            return (int)((duration + 1) / beatLength) * beatLength;
+        }
 
         protected override void Dispose(bool isDisposing)
         {
@@ -274,7 +314,8 @@ namespace osu.Game.Rulesets.Edit
     }
 
     [Cached(typeof(HitObjectComposer))]
-    public abstract class HitObjectComposer : CompositeDrawable
+    [Cached(typeof(IDistanceSnapProvider))]
+    public abstract class HitObjectComposer : CompositeDrawable, IDistanceSnapProvider
     {
         internal HitObjectComposer()
         {
@@ -310,8 +351,11 @@ namespace osu.Game.Rulesets.Edit
         [CanBeNull]
         protected virtual DistanceSnapGrid CreateDistanceSnapGrid([NotNull] IEnumerable<HitObject> selectedHitObjects) => null;
 
-        public abstract Vector2 GetSnappedPosition(Vector2 position);
+        public abstract (Vector2 position, double time) GetSnappedPosition(Vector2 position, double time);
-
+        public abstract float GetBeatSnapDistanceAt(double referenceTime);
-        public abstract double GetSnappedTime(double startTime, Vector2 screenSpacePosition);
+        public abstract float DurationToDistance(double referenceTime, double duration);
+        public abstract double DistanceToDuration(double referenceTime, float distance);
+        public abstract double GetSnappedDurationFromDistance(double referenceTime, float distance);
+        public abstract float GetSnappedDistanceFromDistance(double referenceTime, float distance);
     }
 }

osu.Game/Rulesets/Edit/IDistanceSnapProvider.cs

@@ -0,0 +1,51 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osuTK;
+
+namespace osu.Game.Rulesets.Edit
+{
+    public interface IDistanceSnapProvider
+    {
+        (Vector2 position, double time) GetSnappedPosition(Vector2 position, double time);
+
+        /// <summary>
+        /// Retrieves the distance between two points within a timing point that are one beat length apart.
+        /// </summary>
+        /// <param name="referenceTime">The time of the timing point.</param>
+        /// <returns>The distance between two points residing in the timing point that are one beat length apart.</returns>
+        float GetBeatSnapDistanceAt(double referenceTime);
+
+        /// <summary>
+        /// Converts a duration to a distance.
+        /// </summary>
+        /// <param name="referenceTime">The time of the timing point which <paramref name="duration"/> resides in.</param>
+        /// <param name="duration">The duration to convert.</param>
+        /// <returns>A value that represents <paramref name="duration"/> as a distance in the timing point.</returns>
+        float DurationToDistance(double referenceTime, double duration);
+
+        /// <summary>
+        /// Converts a distance to a duration.
+        /// </summary>
+        /// <param name="referenceTime">The time of the timing point which <paramref name="distance"/> resides in.</param>
+        /// <param name="distance">The distance to convert.</param>
+        /// <returns>A value that represents <paramref name="distance"/> as a duration in the timing point.</returns>
+        double DistanceToDuration(double referenceTime, float distance);
+
+        /// <summary>
+        /// Converts a distance to a snapped duration.
+        /// </summary>
+        /// <param name="referenceTime">The time of the timing point which <paramref name="distance"/> resides in.</param>
+        /// <param name="distance">The distance to convert.</param>
+        /// <returns>A value that represents <paramref name="distance"/> as a duration snapped to the closest beat of the timing point.</returns>
+        double GetSnappedDurationFromDistance(double referenceTime, float distance);
+
+        /// <summary>
+        /// Converts an unsnapped distance to a snapped distance.
+        /// </summary>
+        /// <param name="referenceTime">The time of the timing point which <paramref name="distance"/> resides in.</param>
+        /// <param name="distance">The distance to convert.</param>
+        /// <returns>A value that represents <paramref name="distance"/> snapped to the closest beat of the timing point.</returns>
+        float GetSnappedDistanceFromDistance(double referenceTime, float distance);
+    }
+}

osu.Game/Screens/Edit/Compose/Components/BlueprintContainer.cs

@@ -231,7 +231,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         private void updatePlacementPosition(Vector2 screenSpacePosition)
         {
-            Vector2 snappedGridPosition = composer.GetSnappedPosition(ToLocalSpace(screenSpacePosition));
+            Vector2 snappedGridPosition = composer.GetSnappedPosition(ToLocalSpace(screenSpacePosition), 0).position;
             Vector2 snappedScreenSpacePosition = ToScreenSpace(snappedGridPosition);
 
             currentPlacement.UpdatePosition(snappedScreenSpacePosition);
@@ -358,13 +358,13 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
             // The final movement position, relative to screenSpaceMovementStartPosition
             Vector2 movePosition = startPosition + e.ScreenSpaceMousePosition - e.ScreenSpaceMouseDownPosition;
-            Vector2 snappedPosition = composer.GetSnappedPosition(ToLocalSpace(movePosition));
+            (Vector2 snappedPosition, double snappedTime) = composer.GetSnappedPosition(ToLocalSpace(movePosition), draggedObject.StartTime);
 
             // Move the hitobjects
             selectionHandler.HandleMovement(new MoveSelectionEvent(movementBlueprint, startPosition, ToScreenSpace(snappedPosition)));
 
             // Apply the start time at the newly snapped-to position
-            double offset = composer.GetSnappedTime(draggedObject.StartTime, snappedPosition) - draggedObject.StartTime;
+            double offset = snappedTime - draggedObject.StartTime;
             foreach (HitObject obj in selectionHandler.SelectedHitObjects)
                 obj.StartTime += offset;
 

osu.Game/Screens/Edit/Compose/Components/CircularDistanceSnapGrid.cs

@@ -63,7 +63,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             }
         }
 
-        public override Vector2 GetSnapPosition(Vector2 position)
+        public override (Vector2 position, double time) GetSnappedPosition(Vector2 position)
         {
             Vector2 direction = position - CentrePosition;
 
@@ -76,7 +76,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
             int radialCount = Math.Max(1, (int)Math.Round(distance / radius));
 
             Vector2 normalisedDirection = direction * new Vector2(1f / distance);
-            return CentrePosition + normalisedDirection * radialCount * radius;
+            Vector2 snappedPosition = CentrePosition + normalisedDirection * radialCount * radius;
+
+            return (snappedPosition, StartTime + SnapProvider.GetSnappedDurationFromDistance(StartTime, (snappedPosition - CentrePosition).Length));
         }
     }
 }

osu.Game/Screens/Edit/Compose/Components/DistanceSnapGrid.cs

@@ -6,9 +6,8 @@ using osu.Framework.Caching;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
-using osu.Game.Beatmaps;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osuTK;
@@ -20,16 +19,16 @@ namespace osu.Game.Screens.Edit.Compose.Components
     /// </summary>
     public abstract class DistanceSnapGrid : CompositeDrawable
     {
-        /// <summary>
-        /// The velocity of the beatmap at the point of placement in pixels per millisecond.
-        /// </summary>
-        protected double Velocity { get; private set; }
-
         /// <summary>
         /// The spacing between each tick of the beat snapping grid.
         /// </summary>
         protected float DistanceSpacing { get; private set; }
 
+        /// <summary>
+        /// The snapping time at <see cref="CentrePosition"/>.
+        /// </summary>
+        protected double StartTime { get; private set; }
+
         /// <summary>
         /// The position which the grid is centred on.
         /// The first beat snapping tick is located at <see cref="CentrePosition"/> + <see cref="DistanceSpacing"/> in the desired direction.
@@ -39,6 +38,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
         [Resolved]
         protected OsuColour Colours { get; private set; }
 
+        [Resolved]
+        protected IDistanceSnapProvider SnapProvider { get; private set; }
+
         [Resolved]
         private IEditorBeatmap beatmap { get; set; }
 
@@ -48,22 +50,18 @@ namespace osu.Game.Screens.Edit.Compose.Components
         private readonly Cached gridCache = new Cached();
         private readonly HitObject hitObject;
 
-        private double startTime;
-        private double beatLength;
-
         protected DistanceSnapGrid(HitObject hitObject, Vector2 centrePosition)
         {
             this.hitObject = hitObject;
-            this.CentrePosition = centrePosition;
 
+            CentrePosition = centrePosition;
             RelativeSizeAxes = Axes.Both;
         }
 
         [BackgroundDependencyLoader]
         private void load()
         {
-            startTime = (hitObject as IHasEndTime)?.EndTime ?? hitObject.StartTime;
+            StartTime = (hitObject as IHasEndTime)?.EndTime ?? hitObject.StartTime;
-            beatLength = beatmap.ControlPointInfo.TimingPointAt(startTime).BeatLength;
         }
 
         protected override void LoadComplete()
@@ -75,8 +73,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         private void updateSpacing()
         {
-            Velocity = GetVelocity(startTime, beatmap.ControlPointInfo, beatmap.BeatmapInfo.BaseDifficulty);
+            DistanceSpacing = SnapProvider.GetBeatSnapDistanceAt(StartTime);
-            DistanceSpacing = (float)(beatLength / beatDivisor.Value * Velocity);
             gridCache.Invalidate();
         }
 
@@ -105,28 +102,12 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// </summary>
         protected abstract void CreateContent(Vector2 centrePosition);
 
-        /// <summary>
-        /// Retrieves the velocity of gameplay at a point in time in pixels per millisecond.
-        /// </summary>
-        /// <param name="time">The time to retrieve the velocity at.</param>
-        /// <param name="controlPointInfo">The beatmap's <see cref="ControlPointInfo"/> at the point in time.</param>
-        /// <param name="difficulty">The beatmap's <see cref="BeatmapDifficulty"/> at the point in time.</param>
-        /// <returns>The velocity.</returns>
-        protected abstract float GetVelocity(double time, ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty);
-
         /// <summary>
         /// Snaps a position to this grid.
         /// </summary>
         /// <param name="position">The original position in coordinate space local to this <see cref="DistanceSnapGrid"/>.</param>
-        /// <returns>The snapped position in coordinate space local to this <see cref="DistanceSnapGrid"/>.</returns>
+        /// <returns>A tuple containing the snapped position in coordinate space local to this <see cref="DistanceSnapGrid"/> and the respective time value.</returns>
-        public abstract Vector2 GetSnapPosition(Vector2 position);
+        public abstract (Vector2 position, double time) GetSnappedPosition(Vector2 position);
-
-        /// <summary>
-        /// Retrieves the time at a snapped position.
-        /// </summary>
-        /// <param name="position">The snapped position in coordinate space local to this <see cref="DistanceSnapGrid"/>.</param>
-        /// <returns>The time at the snapped position.</returns>
-        public double GetSnapTime(Vector2 position) => startTime + (position - CentrePosition).Length / Velocity;
 
         /// <summary>
         /// Retrieves the applicable colour for a beat index.