Merge pull request #13961 from ekrctb/catch-editor-flip

Implement horizontal flipping of hit objects in catch editor

osu.Game.Rulesets.Catch/Edit/CatchHitObjectUtils.cs

@@ -1,7 +1,10 @@
 // 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.Collections.Generic;
+using System.Linq;
 using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI.Scrolling;
 using osuTK;
@@ -20,5 +23,41 @@ namespace osu.Game.Rulesets.Catch.Edit
         {
             return new Vector2(hitObject.OriginalX, hitObjectContainer.PositionAtTime(hitObject.StartTime));
         }
+
+        /// <summary>
+        /// Get the range of horizontal position occupied by the hit object.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="TinyDroplet"/>s are excluded and returns <see cref="PositionRange.EMPTY"/>.
+        /// </remarks>
+        public static PositionRange GetPositionRange(HitObject hitObject)
+        {
+            switch (hitObject)
+            {
+                case Fruit fruit:
+                    return new PositionRange(fruit.OriginalX);
+
+                case Droplet droplet:
+                    return droplet is TinyDroplet ? PositionRange.EMPTY : new PositionRange(droplet.OriginalX);
+
+                case JuiceStream _:
+                    return GetPositionRange(hitObject.NestedHitObjects);
+
+                case BananaShower _:
+                    // A banana shower occupies the whole screen width.
+                    return new PositionRange(0, CatchPlayfield.WIDTH);
+
+                default:
+                    return PositionRange.EMPTY;
+            }
+        }
+
+        /// <summary>
+        /// Get the range of horizontal position occupied by the hit objects.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="TinyDroplet"/>s are excluded.
+        /// </remarks>
+        public static PositionRange GetPositionRange(IEnumerable<HitObject> hitObjects) => hitObjects.Select(GetPositionRange).Aggregate(PositionRange.EMPTY, PositionRange.Union);
     }
 }

osu.Game.Rulesets.Catch/Edit/CatchSelectionHandler.cs

@@ -12,6 +12,7 @@ using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
+using Direction = osu.Framework.Graphics.Direction;
 
 namespace osu.Game.Rulesets.Catch.Edit
 {
@@ -39,18 +40,39 @@ namespace osu.Game.Rulesets.Catch.Edit
 
             EditorBeatmap.PerformOnSelection(h =>
             {
-                if (!(h is CatchHitObject hitObject)) return;
+                if (!(h is CatchHitObject catchObject)) return;
 
-                hitObject.OriginalX += deltaX;
+                catchObject.OriginalX += deltaX;
 
                 // Move the nested hit objects to give an instant result before nested objects are recreated.
-                foreach (var nested in hitObject.NestedHitObjects.OfType<CatchHitObject>())
+                foreach (var nested in catchObject.NestedHitObjects.OfType<CatchHitObject>())
                     nested.OriginalX += deltaX;
             });
 
             return true;
         }
 
+        public override bool HandleFlip(Direction direction)
+        {
+            var selectionRange = CatchHitObjectUtils.GetPositionRange(EditorBeatmap.SelectedHitObjects);
+
+            bool changed = false;
+            EditorBeatmap.PerformOnSelection(h =>
+            {
+                if (h is CatchHitObject catchObject)
+                    changed |= handleFlip(selectionRange, catchObject);
+            });
+            return changed;
+        }
+
+        protected override void OnSelectionChanged()
+        {
+            base.OnSelectionChanged();
+
+            var selectionRange = CatchHitObjectUtils.GetPositionRange(EditorBeatmap.SelectedHitObjects);
+            SelectionBox.CanFlipX = selectionRange.Length > 0 && EditorBeatmap.SelectedHitObjects.Any(h => h is CatchHitObject && !(h is BananaShower));
+        }
+
         /// <summary>
         /// Limit positional movement of the objects by the constraint that moved objects should stay in bounds.
         /// </summary>
@@ -59,20 +81,12 @@ namespace osu.Game.Rulesets.Catch.Edit
         /// <returns>The positional movement with the restriction applied.</returns>
         private float limitMovement(float deltaX, IEnumerable<HitObject> movingObjects)
         {
-            float minX = float.PositiveInfinity;
-            float maxX = float.NegativeInfinity;
-
-            foreach (float x in movingObjects.SelectMany(getOriginalPositions))
-            {
-                minX = Math.Min(minX, x);
-                maxX = Math.Max(maxX, x);
-            }
-
+            var range = CatchHitObjectUtils.GetPositionRange(movingObjects);
             // To make an object with position `x` stay in bounds after `deltaX` movement, `0 <= x + deltaX <= WIDTH` should be satisfied.
             // Subtracting `x`, we get `-x <= deltaX <= WIDTH - x`.
             // We only need to apply the inequality to extreme values of `x`.
-            float lowerBound = -minX;
-            float upperBound = CatchPlayfield.WIDTH - maxX;
+            float lowerBound = -range.Min;
+            float upperBound = CatchPlayfield.WIDTH - range.Max;
             // The inequality may be unsatisfiable if the objects were already out of bounds.
             // In that case, don't move objects at all.
             if (lowerBound > upperBound)
@@ -81,35 +95,25 @@ namespace osu.Game.Rulesets.Catch.Edit
             return Math.Clamp(deltaX, lowerBound, upperBound);
         }
 
-        /// <summary>
-        /// Enumerate X positions that should be contained in-bounds after move offset is applied.
-        /// </summary>
-        private IEnumerable<float> getOriginalPositions(HitObject hitObject)
+        private bool handleFlip(PositionRange selectionRange, CatchHitObject hitObject)
         {
             switch (hitObject)
             {
-                case Fruit fruit:
-                    yield return fruit.OriginalX;
-
-                    break;
+                case BananaShower _:
+                    return false;
 
                 case JuiceStream juiceStream:
-                    foreach (var nested in juiceStream.NestedHitObjects.OfType<CatchHitObject>())
-                    {
-                        // Even if `OriginalX` is outside the playfield, tiny droplets can be moved inside the playfield after the random offset application.
-                        if (!(nested is TinyDroplet))
-                            yield return nested.OriginalX;
-                    }
+                    juiceStream.OriginalX = selectionRange.GetFlippedPosition(juiceStream.OriginalX);
 
-                    break;
+                    foreach (var point in juiceStream.Path.ControlPoints)
+                        point.Position.Value *= new Vector2(-1, 1);
 
-                case BananaShower _:
-                    // A banana shower occupies the whole screen width.
-                    // If the selection contains a banana shower, the selection cannot be moved horizontally.
-                    yield return 0;
-                    yield return CatchPlayfield.WIDTH;
+                    EditorBeatmap.Update(juiceStream);
+                    return true;
 
-                    break;
+                default:
+                    hitObject.OriginalX = selectionRange.GetFlippedPosition(hitObject.OriginalX);
+                    return true;
             }
         }
     }

osu.Game.Rulesets.Catch/Edit/PositionRange.cs

@@ -0,0 +1,42 @@
+// 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;
+
+#nullable enable
+
+namespace osu.Game.Rulesets.Catch.Edit
+{
+    /// <summary>
+    /// Represents either the empty range or a closed interval of horizontal positions in the playfield.
+    /// A <see cref="PositionRange"/> represents a closed interval if it is <see cref="Min"/> &lt;= <see cref="Max"/>, and represents the empty range otherwise.
+    /// </summary>
+    public readonly struct PositionRange
+    {
+        public readonly float Min;
+        public readonly float Max;
+
+        public float Length => Math.Max(0, Max - Min);
+
+        public PositionRange(float value)
+            : this(value, value)
+        {
+        }
+
+        public PositionRange(float min, float max)
+        {
+            Min = min;
+            Max = max;
+        }
+
+        public static PositionRange Union(PositionRange a, PositionRange b) => new PositionRange(Math.Min(a.Min, b.Min), Math.Max(a.Max, b.Max));
+
+        /// <summary>
+        /// Get the given position flipped (mirrored) for the axis at the center of this range.
+        /// Returns the given position unchanged if the range was empty.
+        /// </summary>
+        public float GetFlippedPosition(float x) => Min <= Max ? Max - (x - Min) : x;
+
+        public static readonly PositionRange EMPTY = new PositionRange(float.PositiveInfinity, float.NegativeInfinity);
+    }
+}