Merge pull request #6474 from smoogipoo/osu-beatsnapping-grid

Implement osu!'s beat snapping grid

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

@@ -0,0 +1,210 @@
+// 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.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Framework.MathUtils;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Edit;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Tests
+{
+    public class TestSceneOsuDistanceSnapGrid : ManualInputManagerTestScene
+    {
+        private const double beat_length = 100;
+        private static readonly Vector2 grid_position = new Vector2(512, 384);
+
+        [Cached(typeof(IEditorBeatmap))]
+        private readonly EditorBeatmap<OsuHitObject> editorBeatmap;
+
+        [Cached]
+        private readonly BindableBeatDivisor beatDivisor = new BindableBeatDivisor();
+
+        private TestOsuDistanceSnapGrid grid;
+
+        public TestSceneOsuDistanceSnapGrid()
+        {
+            editorBeatmap = new EditorBeatmap<OsuHitObject>(new OsuBeatmap());
+
+            createGrid();
+        }
+
+        [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)]
+        [TestCase(2)]
+        [TestCase(3)]
+        [TestCase(4)]
+        [TestCase(6)]
+        [TestCase(8)]
+        [TestCase(12)]
+        [TestCase(16)]
+        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);
+        }
+
+        [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);
+        }
+
+        [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));
+            float distance = Vector2.Distance(snappedPosition, grid_position);
+
+            return Precision.AlmostEquals(expectedDistance, distance);
+        });
+
+        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;
+
+            private readonly Drawable cursor;
+
+            public SnappingCursorContainer()
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                InternalChild = cursor = new Circle
+                {
+                    Origin = Anchor.Centre,
+                    Size = new Vector2(50),
+                    Colour = Color4.Red
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                updatePosition(GetContainingInputManager().CurrentState.Mouse.Position);
+            }
+
+            protected override bool OnMouseMove(MouseMoveEvent e)
+            {
+                base.OnMouseMove(e);
+
+                updatePosition(e.ScreenSpaceMousePosition);
+                return true;
+            }
+
+            private void updatePosition(Vector2 screenSpacePosition)
+            {
+                cursor.Position = GetSnapPosition.Invoke(screenSpacePosition);
+            }
+        }
+
+        private class TestOsuDistanceSnapGrid : OsuDistanceSnapGrid
+        {
+            public new float DistanceSpacing => base.DistanceSpacing;
+
+            public TestOsuDistanceSnapGrid(OsuHitObject hitObject)
+                : base(hitObject)
+            {
+            }
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+// 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;
+
+namespace osu.Game.Rulesets.Osu.Edit
+{
+    public class OsuDistanceSnapGrid : CircularDistanceSnapGrid
+    {
+        public OsuDistanceSnapGrid(OsuHitObject hitObject)
+            : base(hitObject, hitObject.StackedEndPosition)
+        {
+        }
+
+        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.Rulesets.Osu/Objects/OsuHitObject.cs

@@ -14,8 +14,16 @@ namespace osu.Game.Rulesets.Osu.Objects
 {
     public abstract class OsuHitObject : HitObject, IHasComboInformation, IHasPosition
     {
+        /// <summary>
+        /// The radius of hit objects (ie. the radius of a <see cref="HitCircle"/>).
+        /// </summary>
         public const float OBJECT_RADIUS = 64;
 
+        /// <summary>
+        /// Scoring distance with a speed-adjusted beat length of 1 second (ie. the speed slider balls move through their track).
+        /// </summary>
+        internal const float BASE_SCORING_DISTANCE = 100;
+
         public double TimePreempt = 600;
         public double TimeFadeIn = 400;
 

osu.Game.Rulesets.Osu/Objects/Slider.cs

@@ -19,11 +19,6 @@ namespace osu.Game.Rulesets.Osu.Objects
 {
     public class Slider : OsuHitObject, IHasCurve
     {
-        /// <summary>
-        /// Scoring distance with a speed-adjusted beat length of 1 second.
-        /// </summary>
-        private const float base_scoring_distance = 100;
-
         public double EndTime => StartTime + this.SpanCount() * Path.Distance / Velocity;
         public double Duration => EndTime - StartTime;
 
@@ -123,7 +118,7 @@ namespace osu.Game.Rulesets.Osu.Objects
             TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime);
             DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime);
 
-            double scoringDistance = base_scoring_distance * difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier;
+            double scoringDistance = BASE_SCORING_DISTANCE * difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier;
 
             Velocity = scoringDistance / timingPoint.BeatLength;
             TickDistance = scoringDistance / difficulty.SliderTickRate * TickDistanceMultiplier;

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

@@ -19,7 +19,7 @@ using osuTK.Graphics;
 
 namespace osu.Game.Tests.Visual.Editor
 {
-    public class TestSceneBeatSnapGrid : EditorClockTestScene
+    public class TestSceneDistanceSnapGrid : EditorClockTestScene
     {
         private const double beat_length = 100;
         private static readonly Vector2 grid_position = new Vector2(512, 384);
@@ -27,9 +27,9 @@ namespace osu.Game.Tests.Visual.Editor
         [Cached(typeof(IEditorBeatmap))]
         private readonly EditorBeatmap<OsuHitObject> editorBeatmap;
 
-        private TestBeatSnapGrid grid;
+        private TestDistanceSnapGrid grid;
 
-        public TestSceneBeatSnapGrid()
+        public TestSceneDistanceSnapGrid()
         {
             editorBeatmap = new EditorBeatmap<OsuHitObject>(new OsuBeatmap());
             editorBeatmap.ControlPointInfo.TimingPoints.Add(new TimingControlPoint { BeatLength = beat_length });
@@ -112,7 +112,7 @@ namespace osu.Game.Tests.Visual.Editor
             AddAssert("snap time is now 0.5 beats away", () => Precision.AlmostEquals(beat_length / 2, grid.GetSnapTime(snapPosition), 0.01));
         }
 
-        private void createGrid(Action<TestBeatSnapGrid> func = null, string description = null)
+        private void createGrid(Action<TestDistanceSnapGrid> func = null, string description = null)
         {
             AddStep($"create grid {description ?? string.Empty}", () =>
             {
@@ -123,20 +123,20 @@ namespace osu.Game.Tests.Visual.Editor
                         RelativeSizeAxes = Axes.Both,
                         Colour = Color4.SlateGray
                     },
-                    grid = new TestBeatSnapGrid(new HitObject(), grid_position)
+                    grid = new TestDistanceSnapGrid(new HitObject(), grid_position)
                 };
 
                 func?.Invoke(grid);
             });
         }
 
-        private class TestBeatSnapGrid : BeatSnapGrid
+        private class TestDistanceSnapGrid : DistanceSnapGrid
         {
             public new float Velocity = 1;
 
             public new float DistanceSpacing => base.DistanceSpacing;
 
-            public TestBeatSnapGrid(HitObject hitObject, Vector2 centrePosition)
+            public TestDistanceSnapGrid(HitObject hitObject, Vector2 centrePosition)
                 : base(hitObject, centrePosition)
             {
             }

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

@@ -0,0 +1,59 @@
+// 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.UserInterface;
+using osu.Game.Rulesets.Objects;
+using osuTK;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    public abstract class CircularDistanceSnapGrid : DistanceSnapGrid
+    {
+        protected CircularDistanceSnapGrid(HitObject hitObject, Vector2 centrePosition)
+            : base(hitObject, centrePosition)
+        {
+        }
+
+        protected override void CreateContent(Vector2 centrePosition)
+        {
+            float dx = Math.Max(centrePosition.X, DrawWidth - centrePosition.X);
+            float dy = Math.Max(centrePosition.Y, DrawHeight - centrePosition.Y);
+            float maxDistance = new Vector2(dx, dy).Length;
+
+            int requiredCircles = (int)(maxDistance / DistanceSpacing);
+
+            for (int i = 0; i < requiredCircles; i++)
+            {
+                float radius = (i + 1) * DistanceSpacing * 2;
+
+                AddInternal(new CircularProgress
+                {
+                    Origin = Anchor.Centre,
+                    Position = centrePosition,
+                    Current = { Value = 1 },
+                    Size = new Vector2(radius),
+                    InnerRadius = 4 * 1f / radius,
+                    Colour = GetColourForBeatIndex(i)
+                });
+            }
+        }
+
+        public override Vector2 GetSnapPosition(Vector2 position)
+        {
+            Vector2 direction = position - CentrePosition;
+
+            if (direction == Vector2.Zero)
+                direction = new Vector2(0.001f, 0.001f);
+
+            float distance = direction.Length;
+
+            float radius = DistanceSpacing;
+            int radialCount = Math.Max(1, (int)Math.Round(distance / radius));
+
+            Vector2 normalisedDirection = direction * new Vector2(1f / distance);
+            return CentrePosition + normalisedDirection * radialCount * radius;
+        }
+    }
+}

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

@@ -15,7 +15,10 @@ using osuTK;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
-    public abstract class BeatSnapGrid : CompositeDrawable
+    /// <summary>
+    /// A grid which takes user input and returns a quantized ("snapped") position and time.
+    /// </summary>
+    public abstract class DistanceSnapGrid : CompositeDrawable
     {
         /// <summary>
         /// The velocity of the beatmap at the point of placement in pixels per millisecond.
@@ -48,7 +51,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         private double startTime;
         private double beatLength;
 
-        protected BeatSnapGrid(HitObject hitObject, Vector2 centrePosition)
+        protected DistanceSnapGrid(HitObject hitObject, Vector2 centrePosition)
         {
             this.hitObject = hitObject;
             this.CentrePosition = centrePosition;
@@ -114,14 +117,14 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// <summary>
         /// Snaps a position to this grid.
         /// </summary>
-        /// <param name="position">The original position in coordinate space local to this <see cref="BeatSnapGrid"/>.</param>
-        /// <returns>The snapped position in coordinate space local to this <see cref="BeatSnapGrid"/>.</returns>
+        /// <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>
         public abstract Vector2 GetSnapPosition(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="BeatSnapGrid"/>.</param>
+        /// <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;