Merge 21de5a837a into ce8e4120b7

Do not deselect objects when control-clicking without hitting anything

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

@@ -10,6 +10,7 @@ using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Screens.Edit.Changes;
 using osu.Game.Screens.Edit.Compose.Components;
 using osuTK;
 using Direction = osu.Framework.Graphics.Direction;
@@ -95,9 +96,10 @@ namespace osu.Game.Rulesets.Catch.Edit
 
                 if (h is JuiceStream juiceStream)
                 {
-                    juiceStream.Path.Reverse(out Vector2 positionalOffset);
-                    juiceStream.OriginalX += positionalOffset.X;
-                    juiceStream.LegacyConvertedY += positionalOffset.Y;
+                    var reverse = new ReverseSliderPathChange(juiceStream.Path);
+                    reverse.Apply();
+                    juiceStream.OriginalX += reverse.PositionalOffset.X;
+                    juiceStream.LegacyConvertedY += reverse.PositionalOffset.Y;
                     EditorBeatmap.Update(juiceStream);
                 }
             }

osu.Game.Rulesets.Mania/Edit/Setup/ManiaDifficultySection.cs

@@ -55,7 +55,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
                 {
                     Caption = "Use special (N+1) style",
                     HintText = "Changes one column to act as a classic \"scratch\" or \"special\" column, which can be moved around by the user's skin (to the left/right/centre). Generally used in 6K (5+1) or 8K (7+1) configurations.",
-                    Current = { Value = Beatmap.BeatmapInfo.SpecialStyle }
+                    Current = { Value = Beatmap.SpecialStyle }
                 },
                 healthDrainSlider = new FormSliderBar<float>
                 {
@@ -157,7 +157,7 @@ namespace osu.Game.Rulesets.Mania.Edit.Setup
             // for now, update these on commit rather than making BeatmapMetadata bindables.
             // after switching database engines we can reconsider if switching to bindables is a good direction.
             Beatmap.Difficulty.CircleSize = keyCountSlider.Current.Value;
-            Beatmap.BeatmapInfo.SpecialStyle = specialStyle.Current.Value;
+            Beatmap.SpecialStyle = specialStyle.Current.Value;
             Beatmap.Difficulty.DrainRate = healthDrainSlider.Current.Value;
             Beatmap.Difficulty.OverallDifficulty = overallDifficultySlider.Current.Value;
             Beatmap.Difficulty.SliderMultiplier = baseVelocitySlider.Current.Value;

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuComposerSelection.cs

@@ -231,6 +231,36 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
             AddAssert("slider still has 2 anchors", () => secondSlider.Path.ControlPoints.Count, () => Is.EqualTo(2));
         }
 
+        [Test]
+        public void TestControlClickDoesNotDiscardExistingSelectionEvenIfNothingHit()
+        {
+            var firstSlider = new Slider
+            {
+                StartTime = 0,
+                Position = new Vector2(0, 0),
+                Path = new SliderPath
+                {
+                    ControlPoints =
+                    {
+                        new PathControlPoint(),
+                        new PathControlPoint(new Vector2(100))
+                    }
+                }
+            };
+
+            AddStep("add object", () => EditorBeatmap.AddRange([firstSlider]));
+            AddStep("select first slider", () => EditorBeatmap.SelectedHitObjects.AddRange([firstSlider]));
+
+            AddStep("move mouse to middle of playfield", () => InputManager.MoveMouseTo(blueprintContainer.ScreenSpaceDrawQuad.Centre));
+            AddStep("control-click left mouse", () =>
+            {
+                InputManager.PressKey(Key.ControlLeft);
+                InputManager.Click(MouseButton.Left);
+                InputManager.ReleaseKey(Key.ControlLeft);
+            });
+            AddAssert("selection preserved", () => EditorBeatmap.SelectedHitObjects.Count, () => Is.EqualTo(1));
+        }
+
         private ComposeBlueprintContainer blueprintContainer
             => Editor.ChildrenOfType<ComposeBlueprintContainer>().First();
 

osu.Game.Rulesets.Osu.Tests/Editor/TestSceneOsuEditorGrids.cs

@@ -191,7 +191,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Editor
 
         private void gridSizeIs(int size)
             => AddAssert($"grid size is {size}", () => this.ChildrenOfType<RectangularPositionSnapGrid>().Single().Spacing.Value == new Vector2(size)
-                                                       && EditorBeatmap.BeatmapInfo.GridSize == size);
+                                                       && EditorBeatmap.GridSize == size);
 
         [Test]
         public void TestGridTypeToggling()

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModFlashlight.cs

@@ -83,10 +83,7 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
                             })
                         }
                     },
-                    BeatmapInfo =
-                    {
-                        StackLeniency = 0,
-                    }
+                    StackLeniency = 0,
                 },
                 ReplayFrames = new List<ReplayFrame>
                 {

osu.Game.Rulesets.Osu.Tests/Mods/TestSceneOsuModRandom.cs

@@ -74,12 +74,12 @@ namespace osu.Game.Rulesets.Osu.Tests.Mods
             {
                 BeatmapInfo = new BeatmapInfo
                 {
-                    StackLeniency = 0,
                     Difficulty = new BeatmapDifficulty
                     {
                         ApproachRate = 8.5f
                     }
                 },
+                StackLeniency = 0,
                 ControlPointInfo = controlPointInfo
             };
 

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

@@ -465,7 +465,7 @@ namespace osu.Game.Rulesets.Osu.Tests
         private void performTest(List<ReplayFrame> frames, Beatmap<OsuHitObject> beatmap)
         {
             beatmap.BeatmapInfo.Ruleset = new OsuRuleset().RulesetInfo;
-            beatmap.BeatmapInfo.StackLeniency = 0;
+            beatmap.StackLeniency = 0;
             beatmap.BeatmapInfo.Difficulty = new BeatmapDifficulty
             {
                 SliderMultiplier = 4,

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapProcessor.cs

@@ -56,13 +56,13 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                     h.StackHeight = 0;
 
                 if (beatmap.BeatmapInfo.BeatmapVersion >= 6)
-                    applyStacking(beatmap.BeatmapInfo, hitObjects, 0, hitObjects.Count - 1);
+                    applyStacking(beatmap, hitObjects, 0, hitObjects.Count - 1);
                 else
-                    applyStackingOld(beatmap.BeatmapInfo, hitObjects);
+                    applyStackingOld(beatmap, hitObjects);
             }
         }
 
-        private static void applyStacking(BeatmapInfo beatmapInfo, List<OsuHitObject> hitObjects, int startIndex, int endIndex)
+        private static void applyStacking(IBeatmap beatmap, List<OsuHitObject> hitObjects, int startIndex, int endIndex)
         {
             ArgumentOutOfRangeException.ThrowIfGreaterThan(startIndex, endIndex);
             ArgumentOutOfRangeException.ThrowIfNegative(startIndex);
@@ -87,7 +87,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                             continue;
 
                         double endTime = stackBaseObject.GetEndTime();
-                        double stackThreshold = objectN.TimePreempt * beatmapInfo.StackLeniency;
+                        double stackThreshold = objectN.TimePreempt * beatmap.StackLeniency;
 
                         if (objectN.StartTime - endTime > stackThreshold)
                             // We are no longer within stacking range of the next object.
@@ -132,7 +132,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 OsuHitObject objectI = hitObjects[i];
                 if (objectI.StackHeight != 0 || objectI is Spinner) continue;
 
-                double stackThreshold = objectI.TimePreempt * beatmapInfo.StackLeniency;
+                double stackThreshold = objectI.TimePreempt * beatmap.StackLeniency;
 
                 /* If this object is a hitcircle, then we enter this "special" case.
                  * It either ends with a stack of hitcircles only, or a stack of hitcircles that are underneath a slider.
@@ -214,7 +214,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
             }
         }
 
-        private static void applyStackingOld(BeatmapInfo beatmapInfo, List<OsuHitObject> hitObjects)
+        private static void applyStackingOld(IBeatmap beatmap, List<OsuHitObject> hitObjects)
         {
             for (int i = 0; i < hitObjects.Count; i++)
             {
@@ -228,7 +228,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
 
                 for (int j = i + 1; j < hitObjects.Count; j++)
                 {
-                    double stackThreshold = hitObjects[i].TimePreempt * beatmapInfo.StackLeniency;
+                    double stackThreshold = hitObjects[i].TimePreempt * beatmap.StackLeniency;
 
                     if (hitObjects[j].StartTime - stackThreshold > startTime)
                         break;

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

@@ -24,8 +24,10 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Edit.Changes;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Changes;
 using osuTK;
 using osuTK.Input;
 
@@ -113,7 +115,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                 return;
 
             if (segment.Count > 3)
-                first.Type = PathType.BEZIER;
+                new PathControlPointTypeChange(first, PathType.BEZIER).Apply(changeHandler);
 
             if (segment.Count != 3)
                 return;
@@ -121,7 +123,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             ReadOnlySpan<Vector2> points = segment.Select(p => p.Position).ToArray();
             RectangleF boundingBox = PathApproximator.CircularArcBoundingBox(points);
             if (boundingBox.Width >= 640 || boundingBox.Height >= 480)
-                first.Type = PathType.BEZIER;
+                new PathControlPointTypeChange(first, PathType.BEZIER).Apply(changeHandler);
         }
 
         /// <summary>
@@ -371,26 +373,23 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                     int thirdPointIndex = indexInSegment + 2;
 
                     if (pointsInSegment.Count > thirdPointIndex + 1)
-                        pointsInSegment[thirdPointIndex].Type = pointsInSegment[0].Type;
+                        new PathControlPointTypeChange(pointsInSegment[thirdPointIndex], pointsInSegment[0].Type).Apply(changeHandler);
                 }
 
-                hitObject.Path.ExpectedDistance.Value = null;
-                p.ControlPoint.Type = type;
+                new ExpectedDistanceChange(hitObject.Path, null).Apply(changeHandler);
+                new PathControlPointTypeChange(p.ControlPoint, type).Apply(changeHandler);
             }
 
             EnsureValidPathTypes();
 
             if (hitObject.Path.Distance < originalDistance)
-                hitObject.SnapTo(distanceSnapProvider);
+                new SnapToChange<T>(hitObject, distanceSnapProvider).Apply(changeHandler);
             else
-                hitObject.Path.ExpectedDistance.Value = originalDistance;
+                new ExpectedDistanceChange(hitObject.Path, originalDistance).Apply(changeHandler);
 
             changeHandler?.EndChange();
         }
 
-        [Resolved(CanBeNull = true)]
-        private IEditorChangeHandler changeHandler { get; set; }
-
         #region Drag handling
 
         private Vector2[] dragStartPositions;
@@ -412,6 +411,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
             changeHandler?.BeginChange();
         }
 
+        [Resolved(CanBeNull = true)]
+        private NewBeatmapEditorChangeHandler changeHandler { get; set; }
+
         public void DragInProgress(DragEvent e)
         {
             Vector2[] oldControlPoints = hitObject.Path.ControlPoints.Select(cp => cp.Position).ToArray();
@@ -426,8 +428,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 
                 Vector2 movementDelta = Parent!.ToLocalSpace(result?.ScreenSpacePosition ?? newHeadPosition) - hitObject.Position;
 
-                hitObject.Position += movementDelta;
-                hitObject.StartTime = result?.Time ?? hitObject.StartTime;
+                new PositionChange(hitObject, hitObject.Position + movementDelta).Apply(changeHandler);
+                new StartTimeChange(hitObject, result?.Time ?? hitObject.StartTime).Apply(changeHandler);
 
                 for (int i = 1; i < hitObject.Path.ControlPoints.Count; i++)
                 {
@@ -437,7 +439,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                     // All other selected control points (if any) will move together with the head point
                     // (and so they will not move at all, relative to each other).
                     if (!selectedControlPoints.Contains(controlPoint))
-                        controlPoint.Position -= movementDelta;
+                        new PathControlPointPositionChange(controlPoint, controlPoint.Position - movementDelta).Apply(changeHandler);
                 }
             }
             else
@@ -450,28 +452,28 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
                 {
                     PathControlPoint controlPoint = controlPoints[i];
                     if (selectedControlPoints.Contains(controlPoint))
-                        controlPoint.Position = dragStartPositions[i] + movementDelta;
+                        new PathControlPointPositionChange(controlPoint, dragStartPositions[i] + movementDelta).Apply(changeHandler);
                 }
             }
 
             // Snap the path to the current beat divisor before checking length validity.
-            hitObject.SnapTo(distanceSnapProvider);
+            new SnapToChange<T>(hitObject, distanceSnapProvider).Apply(changeHandler);
 
             if (!hitObject.Path.HasValidLength)
             {
                 for (int i = 0; i < hitObject.Path.ControlPoints.Count; i++)
-                    hitObject.Path.ControlPoints[i].Position = oldControlPoints[i];
+                    new PathControlPointPositionChange(hitObject.Path.ControlPoints[i], oldControlPoints[i]).Apply(changeHandler);
 
-                hitObject.Position = oldPosition;
-                hitObject.StartTime = oldStartTime;
+                new PositionChange(hitObject, oldPosition).Apply(changeHandler);
+                new StartTimeChange(hitObject, oldStartTime).Apply(changeHandler);
                 // Snap the path length again to undo the invalid length.
-                hitObject.SnapTo(distanceSnapProvider);
+                new SnapToChange<T>(hitObject, distanceSnapProvider).Apply(changeHandler);
                 return;
             }
 
             // Maintain the path types in case they got defaulted to bezier at some point during the drag.
             for (int i = 0; i < hitObject.Path.ControlPoints.Count; i++)
-                hitObject.Path.ControlPoints[i].Type = dragPathTypes[i];
+                new PathControlPointTypeChange(hitObject.Path.ControlPoints[i], dragPathTypes[i]).Apply(changeHandler);
 
             EnsureValidPathTypes();
         }

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

@@ -21,9 +21,11 @@ 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.Edit.Changes;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Changes;
 using osu.Game.Screens.Edit.Compose;
 using osuTK;
 using osuTK.Input;
@@ -50,7 +52,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
         private EditorBeatmap? editorBeatmap { get; set; }
 
         [Resolved]
-        private IEditorChangeHandler? changeHandler { get; set; }
+        private NewBeatmapEditorChangeHandler? changeHandler { get; set; }
 
         [Resolved]
         private BindableBeatDivisor? beatDivisor { get; set; }
@@ -122,6 +124,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             pathVersion.BindValueChanged(_ => editorBeatmap?.Update(HitObject));
 
             BodyPiece.UpdateFrom(HitObject);
+            HitObject.DefaultsApplied += _ => BodyPiece.UpdateFrom(HitObject);
 
             if (editorBeatmap != null)
                 selectedObjects.BindTo(editorBeatmap.SelectedHitObjects);
@@ -280,9 +283,10 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             if (Precision.AlmostEquals(proposedDistance, HitObject.Path.Distance) && Precision.AlmostEquals(proposedVelocity, HitObject.SliderVelocityMultiplier))
                 return;
 
-            HitObject.SliderVelocityMultiplier = proposedVelocity;
-            HitObject.Path.ExpectedDistance.Value = proposedDistance;
+            new SliderVelocityMultiplierChange(HitObject, proposedVelocity).Apply(changeHandler);
+            new ExpectedDistanceChange(HitObject.Path, proposedDistance).Apply(changeHandler);
             editorBeatmap?.Update(HitObject);
+            changeHandler?.RecordUpdate(HitObject);
         }
 
         /// <summary>
@@ -303,8 +307,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
                 if (Precision.AlmostBigger(segmentEnds[segmentIndex], 1, 1E-3))
                 {
-                    sliderPath.ControlPoints.RemoveRange(i + 1, sliderPath.ControlPoints.Count - i - 1);
-                    sliderPath.ControlPoints[^1].Type = null;
+                    new RemoveRangePathControlPointChange(sliderPath.ControlPoints, i + 1, sliderPath.ControlPoints.Count - i - 1).Apply(changeHandler);
+                    new PathControlPointTypeChange(sliderPath.ControlPoints[^1], null).Apply(changeHandler);
                     break;
                 }
 
@@ -442,11 +446,11 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             var pathControlPoint = new PathControlPoint { Position = position };
 
             // Move the control points from the insertion index onwards to make room for the insertion
-            controlPoints.Insert(insertionIndex, pathControlPoint);
+            new InsertPathControlPointChange(HitObject.Path.ControlPoints, insertionIndex, pathControlPoint).Apply(changeHandler);
 
             ControlPointVisualiser?.EnsureValidPathTypes();
 
-            HitObject.SnapTo(distanceSnapProvider);
+            new SnapToChange<Slider>(HitObject, distanceSnapProvider).Apply(changeHandler);
 
             return pathControlPoint;
         }
@@ -462,15 +466,15 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 // The first control point in the slider must have a type, so take it from the previous "first" one
                 // Todo: Should be handled within SliderPath itself
                 if (c == controlPoints[0] && controlPoints.Count > 1 && controlPoints[1].Type == null)
-                    controlPoints[1].Type = controlPoints[0].Type;
+                    new PathControlPointTypeChange(controlPoints[1], controlPoints[0].Type).Apply(changeHandler);
 
-                controlPoints.Remove(c);
+                new RemovePathControlPointChange(HitObject.Path.ControlPoints, c).Apply(changeHandler);
             }
 
             ControlPointVisualiser?.EnsureValidPathTypes();
 
             // Snap the slider to the current beat divisor before checking length validity.
-            HitObject.SnapTo(distanceSnapProvider);
+            new SnapToChange<Slider>(HitObject, distanceSnapProvider).Apply(changeHandler);
 
             // If there are 0 or 1 remaining control points, or the slider has an invalid length, it is in a degenerate form and should be deleted
             if (controlPoints.Count <= 1 || !HitObject.Path.HasValidLength)
@@ -483,8 +487,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             // So the slider needs to be offset by this amount instead, and all control points offset backwards such that the path is re-positioned at (0, 0)
             Vector2 first = controlPoints[0].Position;
             foreach (var c in controlPoints)
-                c.Position -= first;
-            HitObject.Position += first;
+                new PathControlPointPositionChange(c, c.Position - first).Apply(changeHandler);
+
+            new PositionChange(HitObject, HitObject.Position + first).Apply(changeHandler);
         }
 
         private void splitControlPoints(List<PathControlPoint> controlPointsToSplitAt)
@@ -514,7 +519,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
                 // Extract the split portion and remove from the original slider.
                 var splitControlPoints = controlPoints.Take(index + 1).ToList();
-                controlPoints.RemoveRange(0, index);
+                new RemoveRangePathControlPointChange(HitObject.Path.ControlPoints, 0, index).Apply(changeHandler);
 
                 var newSlider = new Slider
                 {
@@ -528,18 +533,18 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
                 };
 
                 // Increase the start time of the slider before adding the new slider so the new slider is immediately inserted at the correct index and internal state remains valid.
-                HitObject.StartTime += split_gap;
+                new StartTimeChange(HitObject, HitObject.StartTime + split_gap).Apply(changeHandler);
 
-                editorBeatmap.Add(newSlider);
+                new AddHitObjectChange(editorBeatmap, newSlider).Apply(changeHandler);
 
-                HitObject.NewCombo = false;
-                HitObject.Path.ExpectedDistance.Value -= newSlider.Path.CalculatedDistance;
-                HitObject.StartTime += newSlider.SpanDuration;
+                new NewComboChange(HitObject, false).Apply(changeHandler);
+                new ExpectedDistanceChange(HitObject.Path, HitObject.Path.ExpectedDistance.Value - newSlider.Path.CalculatedDistance).Apply(changeHandler);
+                new StartTimeChange(HitObject, HitObject.StartTime + newSlider.SpanDuration).Apply(changeHandler);
 
                 // In case the remainder of the slider has no length left over, give it length anyways so we don't get a 0 length slider.
                 if (HitObject.Path.ExpectedDistance.Value <= Precision.DOUBLE_EPSILON)
                 {
-                    HitObject.Path.ExpectedDistance.Value = null;
+                    new ExpectedDistanceChange(HitObject.Path, null).Apply(changeHandler);
                 }
             }
 
@@ -547,8 +552,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
             // As a final step, we must reset its control points to have an origin of (0,0).
             Vector2 first = controlPoints[0].Position;
             foreach (var c in controlPoints)
-                c.Position -= first;
-            HitObject.Position += first;
+                new PathControlPointPositionChange(c, c.Position - first).Apply(changeHandler);
+
+            new PositionChange(HitObject, HitObject.Position + first).Apply(changeHandler);
         }
 
         private void convertToStream()
@@ -576,19 +582,19 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 
                 Vector2 position = HitObject.Position + HitObject.Path.PositionAt(pathPosition);
 
-                editorBeatmap.Add(new HitCircle
+                new AddHitObjectChange(editorBeatmap, new HitCircle
                 {
                     StartTime = time,
                     Position = position,
                     NewCombo = i == 0 && HitObject.NewCombo,
                     Samples = HitObject.HeadCircle.Samples.Select(s => s.With()).ToList()
-                });
+                }).Apply(changeHandler);
 
                 i += 1;
                 time = HitObject.StartTime + i * streamSpacing;
             }
 
-            editorBeatmap.Remove(HitObject);
+            new RemoveHitObjectChange(editorBeatmap, HitObject).Apply(changeHandler);
 
             changeHandler?.EndChange();
         }

osu.Game.Rulesets.Osu/Edit/Changes/PositionChange.cs

@@ -0,0 +1,21 @@
+// 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.Rulesets.Osu.Objects;
+using osu.Game.Screens.Edit.Changes;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Changes
+{
+    public class PositionChange : PropertyChange<OsuHitObject, Vector2>
+    {
+        public PositionChange(OsuHitObject target, Vector2 value)
+            : base(target, value)
+        {
+        }
+
+        protected override Vector2 ReadValue(OsuHitObject target) => target.Position;
+
+        protected override void WriteValue(OsuHitObject target, Vector2 value) => target.Position = value;
+    }
+}

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

@@ -170,7 +170,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                 },
             };
 
-            Spacing.Value = editorBeatmap.BeatmapInfo.GridSize;
+            Spacing.Value = editorBeatmap.GridSize;
         }
 
         protected override void LoadComplete()
@@ -204,7 +204,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                 spacingSlider.ContractedLabelText = $"S: {spacing.NewValue:#,0.##}";
                 spacingSlider.ExpandedLabelText = $"Spacing: {spacing.NewValue:#,0.##}";
                 SpacingVector.Value = new Vector2(spacing.NewValue);
-                editorBeatmap.BeatmapInfo.GridSize = (int)spacing.NewValue;
+                editorBeatmap.GridSize = (int)spacing.NewValue;
             }, true);
 
             GridLinesRotation.BindValueChanged(rotation =>

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

@@ -15,8 +15,11 @@ using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Beatmaps;
+using osu.Game.Rulesets.Osu.Edit.Changes;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
+using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Changes;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Utils;
 using osuTK;
@@ -51,6 +54,9 @@ namespace osu.Game.Rulesets.Osu.Edit
             return false;
         }
 
+        [Resolved(canBeNull: true)]
+        private NewBeatmapEditorChangeHandler? changeHandler { get; set; }
+
         public override bool HandleMovement(MoveSelectionEvent<HitObject> moveEvent)
         {
             var hitObjects = selectedMovableObjects;
@@ -72,7 +78,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             // this will potentially move the selection out of bounds...
             foreach (var h in hitObjects)
-                h.Position += localDelta;
+                new PositionChange(h, h.Position + localDelta).Apply(changeHandler);
 
             // but this will be corrected.
             moveSelectionInBounds();
@@ -105,12 +111,13 @@ namespace osu.Game.Rulesets.Osu.Edit
             foreach (var h in hitObjects)
             {
                 if (moreThanOneObject)
-                    h.StartTime = endTime - (h.GetEndTime() - startTime);
+                    new StartTimeChange(h, endTime - (h.GetEndTime() - startTime)).Apply(changeHandler);
 
                 if (h is Slider slider)
                 {
-                    slider.Path.Reverse(out Vector2 offset);
-                    slider.Position += offset;
+                    var reverse = new ReverseSliderPathChange(slider.Path);
+                    reverse.Apply(changeHandler);
+                    new PositionChange(slider, slider.Position + reverse.PositionalOffset).Apply(changeHandler);
                 }
             }
 
@@ -118,7 +125,7 @@ namespace osu.Game.Rulesets.Osu.Edit
             hitObjects = hitObjects.OrderBy(obj => obj.StartTime).ToList();
 
             for (int i = 0; i < hitObjects.Count; ++i)
-                hitObjects[i].NewCombo = newComboOrder[i];
+                new NewComboChange(hitObjects[i], newComboOrder[i]).Apply(changeHandler);
 
             return true;
         }
@@ -167,7 +174,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
                 if (!Precision.AlmostEquals(flippedPosition, h.Position))
                 {
-                    h.Position = flippedPosition;
+                    new PositionChange(h, flippedPosition).Apply(changeHandler);
                     didFlip = true;
                 }
 
@@ -176,7 +183,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                     didFlip = true;
 
                     foreach (var cp in slider.Path.ControlPoints)
-                        cp.Position = GeometryUtils.GetFlippedPosition(flipAxis, controlPointFlipQuad, cp.Position);
+                        new PathControlPointPositionChange(cp, GeometryUtils.GetFlippedPosition(flipAxis, controlPointFlipQuad, cp.Position)).Apply(changeHandler);
                 }
             }
 
@@ -206,7 +213,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                 delta.Y -= quad.BottomRight.Y - DrawHeight;
 
             foreach (var h in hitObjects)
-                h.Position += delta;
+                new PositionChange(h, h.Position + delta).Apply(changeHandler);
         }
 
         /// <summary>
@@ -245,7 +252,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             if (mergedHitObject.Path.ControlPoints.Count == 0)
             {
-                mergedHitObject.Path.ControlPoints.Add(new PathControlPoint(Vector2.Zero, PathType.LINEAR));
+                new InsertPathControlPointChange(mergedHitObject.Path.ControlPoints, mergedHitObject.Path.ControlPoints.Count, new PathControlPoint(Vector2.Zero, PathType.LINEAR)).Apply(changeHandler);
             }
 
             // Merge all the selected hit objects into one slider path.
@@ -259,15 +266,15 @@ namespace osu.Game.Rulesets.Osu.Edit
                     float distanceToLastControlPoint = Vector2.Distance(mergedHitObject.Path.ControlPoints[^1].Position, offset);
 
                     // Calculate the distance required to travel to the expected distance of the merging slider.
-                    mergedHitObject.Path.ExpectedDistance.Value = mergedHitObject.Path.CalculatedDistance + distanceToLastControlPoint + hasPath.Path.Distance;
+                    new ExpectedDistanceChange(mergedHitObject.Path, mergedHitObject.Path.CalculatedDistance + distanceToLastControlPoint + hasPath.Path.Distance).Apply(changeHandler);
 
                     // Remove the last control point if it sits exactly on the start of the next control point.
                     if (Precision.AlmostEquals(distanceToLastControlPoint, 0))
                     {
-                        mergedHitObject.Path.ControlPoints.RemoveAt(mergedHitObject.Path.ControlPoints.Count - 1);
+                        new RemovePathControlPointChange(mergedHitObject.Path.ControlPoints, mergedHitObject.Path.ControlPoints.Count - 1).Apply(changeHandler);
                     }
 
-                    mergedHitObject.Path.ControlPoints.AddRange(hasPath.Path.ControlPoints.Select(o => new PathControlPoint(o.Position + offset, o.Type)));
+                    new AddRangePathControlPointChange(mergedHitObject.Path.ControlPoints, hasPath.Path.ControlPoints.Select(o => new PathControlPoint(o.Position + offset, o.Type))).Apply(changeHandler);
                     lastCircle = false;
                 }
                 else
@@ -275,11 +282,11 @@ namespace osu.Game.Rulesets.Osu.Edit
                     // Turn the last control point into a linear type if this is the first merging circle in a sequence, so the subsequent control points can be inherited path type.
                     if (!lastCircle)
                     {
-                        mergedHitObject.Path.ControlPoints.Last().Type = PathType.LINEAR;
+                        new PathControlPointTypeChange(mergedHitObject.Path.ControlPoints.Last(), PathType.LINEAR).Apply(changeHandler);
                     }
 
-                    mergedHitObject.Path.ControlPoints.Add(new PathControlPoint(selectedMergeableObject.Position - mergedHitObject.Position));
-                    mergedHitObject.Path.ExpectedDistance.Value = null;
+                    new InsertPathControlPointChange(mergedHitObject.Path.ControlPoints, mergedHitObject.Path.ControlPoints.Count, new PathControlPoint(selectedMergeableObject.Position - mergedHitObject.Position)).Apply(changeHandler);
+                    new ExpectedDistanceChange(mergedHitObject.Path, null).Apply(changeHandler);
                     lastCircle = true;
                 }
             }
@@ -289,17 +296,17 @@ namespace osu.Game.Rulesets.Osu.Edit
             {
                 foreach (var selectedMergeableObject in mergeableObjects.Skip(1))
                 {
-                    EditorBeatmap.Remove(selectedMergeableObject);
+                    new RemoveHitObjectChange(EditorBeatmap, selectedMergeableObject).Apply(changeHandler);
                 }
             }
             else
             {
                 foreach (var selectedMergeableObject in mergeableObjects)
                 {
-                    EditorBeatmap.Remove(selectedMergeableObject);
+                    new RemoveHitObjectChange(EditorBeatmap, selectedMergeableObject).Apply(changeHandler);
                 }
 
-                EditorBeatmap.Add(mergedHitObject);
+                new AddHitObjectChange(EditorBeatmap, mergedHitObject).Apply(changeHandler);
             }
 
             // Make sure the merged hitobject is selected.

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

@@ -9,8 +9,10 @@ using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Edit.Changes;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Changes;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Utils;
 using osuTK;
@@ -20,7 +22,7 @@ namespace osu.Game.Rulesets.Osu.Edit
     public partial class OsuSelectionRotationHandler : SelectionRotationHandler
     {
         [Resolved]
-        private IEditorChangeHandler? changeHandler { get; set; }
+        private NewBeatmapEditorChangeHandler? changeHandler { get; set; }
 
         private BindableList<HitObject> selectedItems { get; } = new BindableList<HitObject>();
 
@@ -78,14 +80,17 @@ namespace osu.Game.Rulesets.Osu.Edit
 
             foreach (var ho in objectsInRotation)
             {
-                ho.Position = GeometryUtils.RotatePointAroundOrigin(originalPositions[ho], actualOrigin, rotation);
+                new PositionChange(ho, GeometryUtils.RotatePointAroundOrigin(originalPositions[ho], actualOrigin, rotation)).Apply(changeHandler);
 
                 if (ho is IHasPath withPath)
                 {
                     var originalPath = originalPathControlPointPositions[withPath];
 
                     for (int i = 0; i < withPath.Path.ControlPoints.Count; ++i)
-                        withPath.Path.ControlPoints[i].Position = GeometryUtils.RotatePointAroundOrigin(originalPath[i], Vector2.Zero, rotation);
+                    {
+                        new PathControlPointPositionChange(withPath.Path.ControlPoints[i],
+                            GeometryUtils.RotatePointAroundOrigin(originalPath[i], Vector2.Zero, rotation)).Apply(changeHandler);
+                    }
                 }
             }
         }

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

@@ -13,9 +13,11 @@ using osu.Framework.Utils;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
+using osu.Game.Rulesets.Osu.Edit.Changes;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Changes;
 using osu.Game.Screens.Edit.Compose.Components;
 using osu.Game.Utils;
 using osuTK;
@@ -35,7 +37,7 @@ namespace osu.Game.Rulesets.Osu.Edit
         public Bindable<bool> IsScalingSlider { get; private set; } = new BindableBool();
 
         [Resolved]
-        private IEditorChangeHandler? changeHandler { get; set; }
+        private NewBeatmapEditorChangeHandler? changeHandler { get; set; }
 
         [Resolved(CanBeNull = true)]
         private IDistanceSnapProvider? snapProvider { get; set; }
@@ -113,7 +115,7 @@ namespace osu.Game.Rulesets.Osu.Edit
 
                 foreach (var (ho, originalState) in objectsInScale)
                 {
-                    ho.Position = GeometryUtils.GetScaledPosition(scale, actualOrigin, originalState.Position, axisRotation);
+                    new PositionChange(ho, GeometryUtils.GetScaledPosition(scale, actualOrigin, originalState.Position, axisRotation)).Apply(changeHandler);
                 }
             }
 
@@ -166,15 +168,16 @@ namespace osu.Game.Rulesets.Osu.Edit
             // Maintain the path types in case they were defaulted to bezier at some point during scaling
             for (int i = 0; i < slider.Path.ControlPoints.Count; i++)
             {
-                slider.Path.ControlPoints[i].Position = GeometryUtils.GetScaledPosition(scale, Vector2.Zero, originalInfo.PathControlPointPositions[i], axisRotation);
-                slider.Path.ControlPoints[i].Type = originalInfo.PathControlPointTypes[i];
+                new PathControlPointPositionChange(slider.Path.ControlPoints[i],
+                    GeometryUtils.GetScaledPosition(scale, Vector2.Zero, originalInfo.PathControlPointPositions[i], axisRotation)).Apply(changeHandler);
+                new PathControlPointTypeChange(slider.Path.ControlPoints[i], originalInfo.PathControlPointTypes[i]).Apply(changeHandler);
             }
 
             // Snap the slider's length to the current beat divisor
             // to calculate the final resulting duration / bounding box before the final checks.
-            slider.SnapTo(snapProvider);
+            new SnapToChange<Slider>(slider, snapProvider).Apply(changeHandler);
 
-            slider.Position = GeometryUtils.GetScaledPosition(scale, origin, originalInfo.Position, axisRotation);
+            new PositionChange(slider, GeometryUtils.GetScaledPosition(scale, origin, originalInfo.Position, axisRotation)).Apply(changeHandler);
 
             //if sliderhead or sliderend end up outside playfield, revert scaling.
             Quad scaledQuad = GeometryUtils.GetSurroundingQuad(new OsuHitObject[] { slider });
@@ -184,12 +187,14 @@ namespace osu.Game.Rulesets.Osu.Edit
                 return;
 
             for (int i = 0; i < slider.Path.ControlPoints.Count; i++)
-                slider.Path.ControlPoints[i].Position = originalInfo.PathControlPointPositions[i];
+            {
+                new PathControlPointPositionChange(slider.Path.ControlPoints[i], originalInfo.PathControlPointPositions[i]).Apply(changeHandler);
+            }
 
-            slider.Position = originalInfo.Position;
+            new PositionChange(slider, originalInfo.Position).Apply(changeHandler);
 
             // Snap the slider's length again to undo the potentially-invalid length applied by the previous snap.
-            slider.SnapTo(snapProvider);
+            new SnapToChange<Slider>(slider, snapProvider).Apply(changeHandler);
         }
 
         private (bool X, bool Y) isQuadInBounds(Quad quad)
@@ -327,7 +332,7 @@ namespace osu.Game.Rulesets.Osu.Edit
                 delta.Y -= quad.BottomRight.Y - OsuPlayfield.BASE_SIZE.Y;
 
             foreach (var (h, _) in objectsInScale!)
-                h.Position += delta;
+                new PositionChange(h, h.Position + delta).Apply(changeHandler);
         }
 
         private struct OriginalHitObjectState

osu.Game.Rulesets.Osu/Edit/Setup/OsuDifficultySection.cs

@@ -119,7 +119,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Setup
                 {
                     Caption = "Stack Leniency",
                     HintText = "In play mode, osu! automatically stacks notes which occur at the same location. Increasing this value means it is more likely to snap notes of further time-distance.",
-                    Current = new BindableFloat(Beatmap.BeatmapInfo.StackLeniency)
+                    Current = new BindableFloat(Beatmap.StackLeniency)
                     {
                         Default = 0.7f,
                         MinValue = 0,
@@ -148,7 +148,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Setup
             Beatmap.Difficulty.OverallDifficulty = overallDifficultySlider.Current.Value;
             Beatmap.Difficulty.SliderMultiplier = baseVelocitySlider.Current.Value;
             Beatmap.Difficulty.SliderTickRate = tickRateSlider.Current.Value;
-            Beatmap.BeatmapInfo.StackLeniency = stackLeniency.Current.Value;
+            Beatmap.StackLeniency = stackLeniency.Current.Value;
 
             Beatmap.UpdateAllHitObjects();
             Beatmap.SaveState();

osu.Game.Tests/Beatmaps/Formats/LegacyBeatmapDecoderTest.cs

@@ -80,16 +80,16 @@ namespace osu.Game.Tests.Beatmaps.Formats
                 var metadata = beatmap.Metadata;
 
                 Assert.AreEqual("03. Renatus - Soleily 192kbps.mp3", metadata.AudioFile);
-                Assert.AreEqual(0, beatmapInfo.AudioLeadIn);
+                Assert.AreEqual(0, beatmap.AudioLeadIn);
                 Assert.AreEqual(164471, metadata.PreviewTime);
-                Assert.AreEqual(0.7f, beatmapInfo.StackLeniency);
+                Assert.AreEqual(0.7f, beatmap.StackLeniency);
                 Assert.IsTrue(beatmapInfo.Ruleset.OnlineID == 0);
-                Assert.IsFalse(beatmapInfo.LetterboxInBreaks);
-                Assert.IsFalse(beatmapInfo.SpecialStyle);
-                Assert.IsFalse(beatmapInfo.WidescreenStoryboard);
-                Assert.IsFalse(beatmapInfo.SamplesMatchPlaybackRate);
-                Assert.AreEqual(CountdownType.None, beatmapInfo.Countdown);
-                Assert.AreEqual(0, beatmapInfo.CountdownOffset);
+                Assert.IsFalse(beatmap.LetterboxInBreaks);
+                Assert.IsFalse(beatmap.SpecialStyle);
+                Assert.IsFalse(beatmap.WidescreenStoryboard);
+                Assert.IsFalse(beatmap.SamplesMatchPlaybackRate);
+                Assert.AreEqual(CountdownType.None, beatmap.Countdown);
+                Assert.AreEqual(0, beatmap.CountdownOffset);
             }
         }
 
@@ -101,7 +101,7 @@ namespace osu.Game.Tests.Beatmaps.Formats
             using (var resStream = TestResources.OpenResource("Soleily - Renatus (Gamu) [Insane].osu"))
             using (var stream = new LineBufferedReader(resStream))
             {
-                var beatmapInfo = decoder.Decode(stream).BeatmapInfo;
+                var beatmap = decoder.Decode(stream);
 
                 int[] expectedBookmarks =
                 {
@@ -109,13 +109,13 @@ namespace osu.Game.Tests.Beatmaps.Formats
                     95901, 106450, 116999, 119637, 130186, 140735, 151285,
                     161834, 164471, 175020, 185570, 196119, 206669, 209306
                 };
-                Assert.AreEqual(expectedBookmarks.Length, beatmapInfo.Bookmarks.Length);
+                Assert.AreEqual(expectedBookmarks.Length, beatmap.BeatmapInfo.Bookmarks.Length);
                 for (int i = 0; i < expectedBookmarks.Length; i++)
-                    Assert.AreEqual(expectedBookmarks[i], beatmapInfo.Bookmarks[i]);
-                Assert.AreEqual(1.8, beatmapInfo.DistanceSpacing);
-                Assert.AreEqual(4, beatmapInfo.BeatDivisor);
-                Assert.AreEqual(4, beatmapInfo.GridSize);
-                Assert.AreEqual(2, beatmapInfo.TimelineZoom);
+                    Assert.AreEqual(expectedBookmarks[i], beatmap.BeatmapInfo.Bookmarks[i]);
+                Assert.AreEqual(1.8, beatmap.DistanceSpacing);
+                Assert.AreEqual(4, beatmap.BeatmapInfo.BeatDivisor);
+                Assert.AreEqual(4, beatmap.GridSize);
+                Assert.AreEqual(2, beatmap.TimelineZoom);
             }
         }
 
@@ -993,15 +993,15 @@ namespace osu.Game.Tests.Beatmaps.Formats
 
                 Assert.Multiple(() =>
                 {
-                    Assert.That(decoded.BeatmapInfo.AudioLeadIn, Is.EqualTo(0));
-                    Assert.That(decoded.BeatmapInfo.StackLeniency, Is.EqualTo(0.7f));
-                    Assert.That(decoded.BeatmapInfo.SpecialStyle, Is.False);
-                    Assert.That(decoded.BeatmapInfo.LetterboxInBreaks, Is.False);
-                    Assert.That(decoded.BeatmapInfo.WidescreenStoryboard, Is.False);
-                    Assert.That(decoded.BeatmapInfo.EpilepsyWarning, Is.False);
-                    Assert.That(decoded.BeatmapInfo.SamplesMatchPlaybackRate, Is.False);
-                    Assert.That(decoded.BeatmapInfo.Countdown, Is.EqualTo(CountdownType.None));
-                    Assert.That(decoded.BeatmapInfo.CountdownOffset, Is.EqualTo(0));
+                    Assert.That(decoded.AudioLeadIn, Is.EqualTo(0));
+                    Assert.That(decoded.StackLeniency, Is.EqualTo(0.7f));
+                    Assert.That(decoded.SpecialStyle, Is.False);
+                    Assert.That(decoded.LetterboxInBreaks, Is.False);
+                    Assert.That(decoded.WidescreenStoryboard, Is.False);
+                    Assert.That(decoded.EpilepsyWarning, Is.False);
+                    Assert.That(decoded.SamplesMatchPlaybackRate, Is.False);
+                    Assert.That(decoded.Countdown, Is.EqualTo(CountdownType.None));
+                    Assert.That(decoded.CountdownOffset, Is.EqualTo(0));
                     Assert.That(decoded.BeatmapInfo.Metadata.PreviewTime, Is.EqualTo(-1));
                     Assert.That(decoded.BeatmapInfo.Ruleset.OnlineID, Is.EqualTo(0));
                 });

osu.Game.Tests/Beatmaps/Formats/OsuJsonDecoderTest.cs

@@ -51,14 +51,14 @@ namespace osu.Game.Tests.Beatmaps.Formats
         {
             var beatmap = decodeAsJson(normal);
             var beatmapInfo = beatmap.BeatmapInfo;
-            Assert.AreEqual(0, beatmapInfo.AudioLeadIn);
-            Assert.AreEqual(0.7f, beatmapInfo.StackLeniency);
-            Assert.AreEqual(false, beatmapInfo.SpecialStyle);
+            Assert.AreEqual(0, beatmap.AudioLeadIn);
+            Assert.AreEqual(0.7f, beatmap.StackLeniency);
+            Assert.AreEqual(false, beatmap.SpecialStyle);
             Assert.IsTrue(beatmapInfo.Ruleset.OnlineID == 0);
-            Assert.AreEqual(false, beatmapInfo.LetterboxInBreaks);
-            Assert.AreEqual(false, beatmapInfo.WidescreenStoryboard);
-            Assert.AreEqual(CountdownType.None, beatmapInfo.Countdown);
-            Assert.AreEqual(0, beatmapInfo.CountdownOffset);
+            Assert.AreEqual(false, beatmap.LetterboxInBreaks);
+            Assert.AreEqual(false, beatmap.WidescreenStoryboard);
+            Assert.AreEqual(CountdownType.None, beatmap.Countdown);
+            Assert.AreEqual(0, beatmap.CountdownOffset);
         }
 
         [Test]
@@ -76,10 +76,10 @@ namespace osu.Game.Tests.Beatmaps.Formats
             Assert.AreEqual(expectedBookmarks.Length, beatmapInfo.Bookmarks.Length);
             for (int i = 0; i < expectedBookmarks.Length; i++)
                 Assert.AreEqual(expectedBookmarks[i], beatmapInfo.Bookmarks[i]);
-            Assert.AreEqual(1.8, beatmapInfo.DistanceSpacing);
+            Assert.AreEqual(1.8, beatmap.DistanceSpacing);
             Assert.AreEqual(4, beatmapInfo.BeatDivisor);
-            Assert.AreEqual(4, beatmapInfo.GridSize);
-            Assert.AreEqual(2, beatmapInfo.TimelineZoom);
+            Assert.AreEqual(4, beatmap.GridSize);
+            Assert.AreEqual(2, beatmap.TimelineZoom);
         }
 
         [Test]

osu.Game.Tests/Database/RealmSubscriptionRegistrationTests.cs

@@ -41,7 +41,7 @@ namespace osu.Game.Tests.Database
                 Assert.That(lastChanges?.ModifiedIndices, Is.Empty);
                 Assert.That(lastChanges?.NewModifiedIndices, Is.Empty);
 
-                realm.Write(r => r.All<BeatmapSetInfo>().First().Beatmaps.First().CountdownOffset = 5);
+                realm.Write(r => r.All<BeatmapSetInfo>().First().Beatmaps.First().EditorTimestamp = 5);
                 realm.Run(r => r.Refresh());
 
                 Assert.That(collectionChanges, Is.EqualTo(1));

osu.Game.Tests/Visual/Editing/TestSceneDesignSection.cs

@@ -56,7 +56,7 @@ namespace osu.Game.Tests.Visual.Editing
         {
             AddStep("turn countdown off", () => designSection.EnableCountdown.Current.Value = false);
 
-            AddAssert("beatmap has correct type", () => editorBeatmap.BeatmapInfo.Countdown == CountdownType.None);
+            AddAssert("beatmap has correct type", () => editorBeatmap.Countdown == CountdownType.None);
             AddUntilStep("other controls hidden", () => !designSection.CountdownSettings.IsPresent);
         }
 
@@ -65,12 +65,12 @@ namespace osu.Game.Tests.Visual.Editing
         {
             AddStep("turn countdown on", () => designSection.EnableCountdown.Current.Value = true);
 
-            AddAssert("beatmap has correct type", () => editorBeatmap.BeatmapInfo.Countdown == CountdownType.Normal);
+            AddAssert("beatmap has correct type", () => editorBeatmap.Countdown == CountdownType.Normal);
             AddUntilStep("other controls shown", () => designSection.CountdownSettings.IsPresent);
 
             AddStep("change countdown speed", () => designSection.CountdownSpeed.Current.Value = CountdownType.DoubleSpeed);
 
-            AddAssert("beatmap has correct type", () => editorBeatmap.BeatmapInfo.Countdown == CountdownType.DoubleSpeed);
+            AddAssert("beatmap has correct type", () => editorBeatmap.Countdown == CountdownType.DoubleSpeed);
             AddUntilStep("other controls still shown", () => designSection.CountdownSettings.IsPresent);
         }
 
@@ -79,7 +79,7 @@ namespace osu.Game.Tests.Visual.Editing
         {
             AddStep("turn countdown on", () => designSection.EnableCountdown.Current.Value = true);
 
-            AddAssert("beatmap has correct type", () => editorBeatmap.BeatmapInfo.Countdown == CountdownType.Normal);
+            AddAssert("beatmap has correct type", () => editorBeatmap.Countdown == CountdownType.Normal);
 
             checkOffsetAfter("1", 1);
             checkOffsetAfter(string.Empty, 0);
@@ -99,7 +99,7 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("commit text", () => InputManager.Key(Key.Enter));
 
             AddAssert($"displayed value is {expectedFinalValue}", () => designSection.CountdownOffset.Current.Value == expectedFinalValue.ToString(CultureInfo.InvariantCulture));
-            AddAssert($"beatmap value is {expectedFinalValue}", () => editorBeatmap.BeatmapInfo.CountdownOffset == expectedFinalValue);
+            AddAssert($"beatmap value is {expectedFinalValue}", () => editorBeatmap.CountdownOffset == expectedFinalValue);
         }
 
         private partial class TestDesignSection : DesignSection

osu.Game.Tests/Visual/Editing/TestSceneEditorSaving.cs

@@ -70,7 +70,7 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("Set beat divisor", () => Editor.Dependencies.Get<BindableBeatDivisor>().Value = 16);
             AddStep("Set timeline zoom", () =>
             {
-                originalTimelineZoom = EditorBeatmap.BeatmapInfo.TimelineZoom;
+                originalTimelineZoom = EditorBeatmap.TimelineZoom;
 
                 var timeline = Editor.ChildrenOfType<Timeline>().Single();
                 InputManager.MoveMouseTo(timeline);
@@ -81,19 +81,19 @@ namespace osu.Game.Tests.Visual.Editing
 
             AddAssert("Ensure timeline zoom changed", () =>
             {
-                changedTimelineZoom = EditorBeatmap.BeatmapInfo.TimelineZoom;
+                changedTimelineZoom = EditorBeatmap.TimelineZoom;
                 return !Precision.AlmostEquals(changedTimelineZoom, originalTimelineZoom);
             });
 
             SaveEditor();
 
             AddAssert("Beatmap has correct beat divisor", () => EditorBeatmap.BeatmapInfo.BeatDivisor == 16);
-            AddAssert("Beatmap has correct timeline zoom", () => EditorBeatmap.BeatmapInfo.TimelineZoom == changedTimelineZoom);
+            AddAssert("Beatmap has correct timeline zoom", () => EditorBeatmap.TimelineZoom == changedTimelineZoom);
 
             ReloadEditorToSameBeatmap();
 
             AddAssert("Beatmap still has correct beat divisor", () => EditorBeatmap.BeatmapInfo.BeatDivisor == 16);
-            AddAssert("Beatmap still has correct timeline zoom", () => EditorBeatmap.BeatmapInfo.TimelineZoom == changedTimelineZoom);
+            AddAssert("Beatmap still has correct timeline zoom", () => EditorBeatmap.TimelineZoom == changedTimelineZoom);
         }
 
         [Test]

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

@@ -205,7 +205,7 @@ namespace osu.Game.Tests.Visual.Editing
         {
             double originalSpacing = 0;
 
-            AddStep("retrieve original spacing", () => originalSpacing = editorBeatmap.BeatmapInfo.DistanceSpacing);
+            AddStep("retrieve original spacing", () => originalSpacing = editorBeatmap.DistanceSpacing);
 
             AddStep("hold ctrl", () => InputManager.PressKey(Key.LControl));
             AddStep("hold alt", () => InputManager.PressKey(Key.LAlt));
@@ -215,7 +215,7 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("release alt", () => InputManager.ReleaseKey(Key.LAlt));
             AddStep("release ctrl", () => InputManager.ReleaseKey(Key.LControl));
 
-            AddAssert("distance spacing increased by 0.5", () => editorBeatmap.BeatmapInfo.DistanceSpacing == originalSpacing + 0.5);
+            AddAssert("distance spacing increased by 0.5", () => editorBeatmap.DistanceSpacing == originalSpacing + 0.5);
         }
 
         public partial class EditorBeatmapContainer : PopoverContainer

osu.Game.Tests/Visual/Gameplay/TestSceneLeadIn.cs

@@ -32,7 +32,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             loadPlayerWithBeatmap(new TestBeatmap(new OsuRuleset().RulesetInfo)
             {
-                BeatmapInfo = { AudioLeadIn = leadIn }
+                AudioLeadIn = leadIn
             });
 
             checkFirstFrameTime(expectedStartTime);
@@ -133,7 +133,7 @@ namespace osu.Game.Tests.Visual.Gameplay
                     {
                         Text = $"GameplayStartTime: {DrawableRuleset.GameplayStartTime} "
                                + $"FirstHitObjectTime: {FirstHitObjectTime} "
-                               + $"LeadInTime: {Beatmap.Value.BeatmapInfo.AudioLeadIn} "
+                               + $"LeadInTime: {Beatmap.Value.Beatmap.AudioLeadIn} "
                                + $"FirstFrameClockTime: {FirstFrameClockTime}"
                     });
                 }

osu.Game.Tests/Visual/Gameplay/TestScenePlayerLoader.cs

@@ -136,10 +136,10 @@ namespace osu.Game.Tests.Visual.Gameplay
             var workingBeatmap = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
 
             // Add intro time to test quick retry skipping (TestQuickRetry).
-            workingBeatmap.BeatmapInfo.AudioLeadIn = 60000;
+            workingBeatmap.Beatmap.AudioLeadIn = 60000;
 
             // Set up data for testing disclaimer display.
-            workingBeatmap.BeatmapInfo.EpilepsyWarning = epilepsyWarning ?? false;
+            workingBeatmap.Beatmap.EpilepsyWarning = epilepsyWarning ?? false;
             workingBeatmap.BeatmapInfo.Status = onlineStatus ?? BeatmapOnlineStatus.Ranked;
 
             Beatmap.Value = workingBeatmap;

osu.Game.Tests/Visual/Gameplay/TestSceneReplayPlayer.cs

@@ -63,7 +63,7 @@ namespace osu.Game.Tests.Visual.Gameplay
         {
             loadPlayerWithBeatmap(new TestBeatmap(new OsuRuleset().RulesetInfo)
             {
-                BeatmapInfo = { AudioLeadIn = 60000 }
+                AudioLeadIn = 60000
             });
 
             AddUntilStep("wait for skip overlay", () => Player.ChildrenOfType<SkipOverlay>().First().IsButtonVisible);

osu.Game.Tests/Visual/Gameplay/TestSceneStoryboard.cs

@@ -53,7 +53,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("load storyboard with only video", () =>
             {
                 // LegacyStoryboardDecoder doesn't parse WidescreenStoryboard, so it is set manually
-                loadStoryboard("storyboard_only_video.osu", s => s.BeatmapInfo.WidescreenStoryboard = false);
+                loadStoryboard("storyboard_only_video.osu", s => s.Beatmap.WidescreenStoryboard = false);
             });
 
             AddAssert("storyboard is correct width", () => Precision.AlmostEquals(storyboard?.Width ?? 0f, 480 * 16 / 9f));

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs

@@ -406,13 +406,13 @@ namespace osu.Game.Tests.Visual.Multiplayer
         }
 
         /// <summary>
-        /// Tests spectating with a beatmap that has a high <see cref="BeatmapInfo.AudioLeadIn"/> value.
+        /// Tests spectating with a beatmap that has a high <see cref="IBeatmap.AudioLeadIn"/> value.
         ///
         /// This test is not intended not to check the correct initial time value, but only to guard against
         /// gameplay potentially getting stuck in a stopped state due to lead in time being present.
         /// </summary>
         [Test]
-        public void TestAudioLeadIn() => testLeadIn(b => b.BeatmapInfo.AudioLeadIn = 2000);
+        public void TestAudioLeadIn() => testLeadIn(b => b.Beatmap.AudioLeadIn = 2000);
 
         /// <summary>
         /// Tests spectating with a beatmap that has a storyboard element with a negative start time (i.e. intro storyboard element).

osu.Game/Beatmaps/Beatmap.cs

@@ -115,6 +115,30 @@ namespace osu.Game.Beatmaps
             return mostCommon.beatLength;
         }
 
+        public double AudioLeadIn { get; set; }
+
+        public float StackLeniency { get; set; } = 0.7f;
+
+        public bool SpecialStyle { get; set; }
+
+        public bool LetterboxInBreaks { get; set; }
+
+        public bool WidescreenStoryboard { get; set; } = true;
+
+        public bool EpilepsyWarning { get; set; }
+
+        public bool SamplesMatchPlaybackRate { get; set; }
+
+        public double DistanceSpacing { get; set; } = 1.0;
+
+        public int GridSize { get; set; }
+
+        public double TimelineZoom { get; set; } = 1.0;
+
+        public CountdownType Countdown { get; set; } = CountdownType.None;
+
+        public int CountdownOffset { get; set; }
+
         IBeatmap IBeatmap.Clone() => Clone();
 
         public Beatmap<T> Clone() => (Beatmap<T>)MemberwiseClone();

osu.Game/Beatmaps/BeatmapConverter.cs

@@ -73,6 +73,18 @@ namespace osu.Game.Beatmaps
             beatmap.HitObjects = convertHitObjects(original.HitObjects, original, cancellationToken).OrderBy(s => s.StartTime).ToList();
             beatmap.Breaks = original.Breaks;
             beatmap.UnhandledEventLines = original.UnhandledEventLines;
+            beatmap.AudioLeadIn = original.AudioLeadIn;
+            beatmap.StackLeniency = original.StackLeniency;
+            beatmap.SpecialStyle = original.SpecialStyle;
+            beatmap.LetterboxInBreaks = original.LetterboxInBreaks;
+            beatmap.WidescreenStoryboard = original.WidescreenStoryboard;
+            beatmap.EpilepsyWarning = original.EpilepsyWarning;
+            beatmap.SamplesMatchPlaybackRate = original.SamplesMatchPlaybackRate;
+            beatmap.DistanceSpacing = original.DistanceSpacing;
+            beatmap.GridSize = original.GridSize;
+            beatmap.TimelineZoom = original.TimelineZoom;
+            beatmap.Countdown = original.Countdown;
+            beatmap.CountdownOffset = original.CountdownOffset;
 
             return beatmap;
         }

osu.Game/Beatmaps/BeatmapImporter.cs

@@ -428,17 +428,7 @@ namespace osu.Game.Beatmaps
                         Hash = hash,
                         DifficultyName = decodedInfo.DifficultyName,
                         OnlineID = decodedInfo.OnlineID,
-                        AudioLeadIn = decodedInfo.AudioLeadIn,
-                        StackLeniency = decodedInfo.StackLeniency,
-                        SpecialStyle = decodedInfo.SpecialStyle,
-                        LetterboxInBreaks = decodedInfo.LetterboxInBreaks,
-                        WidescreenStoryboard = decodedInfo.WidescreenStoryboard,
-                        EpilepsyWarning = decodedInfo.EpilepsyWarning,
-                        SamplesMatchPlaybackRate = decodedInfo.SamplesMatchPlaybackRate,
-                        DistanceSpacing = decodedInfo.DistanceSpacing,
                         BeatDivisor = decodedInfo.BeatDivisor,
-                        GridSize = decodedInfo.GridSize,
-                        TimelineZoom = decodedInfo.TimelineZoom,
                         MD5Hash = memoryStream.ComputeMD5Hash(),
                         EndTimeObjectCount = decoded.HitObjects.Count(h => h is IHasDuration),
                         TotalObjectCount = decoded.HitObjects.Count

osu.Game/Beatmaps/BeatmapInfo.cs

@@ -6,14 +6,12 @@ using System.Diagnostics;
 using System.Linq;
 using JetBrains.Annotations;
 using Newtonsoft.Json;
-using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Collections;
 using osu.Game.Database;
 using osu.Game.Models;
 using osu.Game.Online.API.Requests.Responses;
 using osu.Game.Overlays.BeatmapSet.Scores;
 using osu.Game.Rulesets;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Scoring;
 using Realms;
 
@@ -136,60 +134,18 @@ namespace osu.Game.Beatmaps
                 Status = BeatmapOnlineStatus.None;
         }
 
-        #region Properties we may not want persisted (but also maybe no harm?)
-
-        public double AudioLeadIn { get; set; }
-
-        public float StackLeniency { get; set; } = 0.7f;
-
-        public bool SpecialStyle { get; set; }
-
-        public bool LetterboxInBreaks { get; set; }
-
-        public bool WidescreenStoryboard { get; set; } = true;
-
-        public bool EpilepsyWarning { get; set; }
-
-        public bool SamplesMatchPlaybackRate { get; set; }
-
         /// <summary>
         /// The time at which this beatmap was last played by the local user.
         /// </summary>
         public DateTimeOffset? LastPlayed { get; set; }
 
-        /// <summary>
-        /// The ratio of distance travelled per time unit.
-        /// Generally used to decouple the spacing between hit objects from the enforced "velocity" of the beatmap (see <see cref="DifficultyControlPoint.SliderVelocity"/>).
-        /// </summary>
-        /// <remarks>
-        /// The most common method of understanding is that at a default value of 1.0, the time-to-distance ratio will match the slider velocity of the beatmap
-        /// at the current point in time. Increasing this value will make hit objects more spaced apart when compared to the cursor movement required to track a slider.
-        ///
-        /// This is only a hint property, used by the editor in <see cref="IDistanceSnapProvider"/> implementations. It does not directly affect the beatmap or gameplay.
-        /// </remarks>
-        public double DistanceSpacing { get; set; } = 1.0;
-
         public int BeatDivisor { get; set; } = 4;
 
-        public int GridSize { get; set; }
-
-        public double TimelineZoom { get; set; } = 1.0;
-
         /// <summary>
         /// The time in milliseconds when last exiting the editor with this beatmap loaded.
         /// </summary>
         public double? EditorTimestamp { get; set; }
 
-        [Ignored]
-        public CountdownType Countdown { get; set; } = CountdownType.None;
-
-        /// <summary>
-        /// The number of beats to move the countdown backwards (compared to its default location).
-        /// </summary>
-        public int CountdownOffset { get; set; }
-
-        #endregion
-
         public bool Equals(BeatmapInfo? other)
         {
             if (ReferenceEquals(this, other)) return true;

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -82,7 +82,7 @@ namespace osu.Game.Beatmaps.Formats
             this.beatmap.BeatmapInfo.BeatmapVersion = FormatVersion;
             parser = new ConvertHitObjectParser(getOffsetTime(), FormatVersion);
 
-            applyLegacyDefaults(this.beatmap.BeatmapInfo);
+            ApplyLegacyDefaults(this.beatmap);
 
             base.ParseStreamInto(stream, beatmap);
 
@@ -190,9 +190,9 @@ namespace osu.Game.Beatmaps.Formats
         /// This method's intention is to restore those legacy defaults.
         /// See also: https://osu.ppy.sh/wiki/en/Client/File_formats/Osu_%28file_format%29
         /// </summary>
-        private static void applyLegacyDefaults(BeatmapInfo beatmapInfo)
+        internal static void ApplyLegacyDefaults(Beatmap beatmap)
         {
-            beatmapInfo.WidescreenStoryboard = false;
+            beatmap.WidescreenStoryboard = false;
         }
 
         protected override void ParseLine(Beatmap beatmap, Section section, string line)
@@ -244,7 +244,7 @@ namespace osu.Game.Beatmaps.Formats
                     break;
 
                 case @"AudioLeadIn":
-                    beatmap.BeatmapInfo.AudioLeadIn = Parsing.ParseInt(pair.Value);
+                    beatmap.AudioLeadIn = Parsing.ParseInt(pair.Value);
                     break;
 
                 case @"PreviewTime":
@@ -261,7 +261,7 @@ namespace osu.Game.Beatmaps.Formats
                     break;
 
                 case @"StackLeniency":
-                    beatmap.BeatmapInfo.StackLeniency = Parsing.ParseFloat(pair.Value);
+                    beatmap.StackLeniency = Parsing.ParseFloat(pair.Value);
                     break;
 
                 case @"Mode":
@@ -269,31 +269,31 @@ namespace osu.Game.Beatmaps.Formats
                     break;
 
                 case @"LetterboxInBreaks":
-                    beatmap.BeatmapInfo.LetterboxInBreaks = Parsing.ParseInt(pair.Value) == 1;
+                    beatmap.LetterboxInBreaks = Parsing.ParseInt(pair.Value) == 1;
                     break;
 
                 case @"SpecialStyle":
-                    beatmap.BeatmapInfo.SpecialStyle = Parsing.ParseInt(pair.Value) == 1;
+                    beatmap.SpecialStyle = Parsing.ParseInt(pair.Value) == 1;
                     break;
 
                 case @"WidescreenStoryboard":
-                    beatmap.BeatmapInfo.WidescreenStoryboard = Parsing.ParseInt(pair.Value) == 1;
+                    beatmap.WidescreenStoryboard = Parsing.ParseInt(pair.Value) == 1;
                     break;
 
                 case @"EpilepsyWarning":
-                    beatmap.BeatmapInfo.EpilepsyWarning = Parsing.ParseInt(pair.Value) == 1;
+                    beatmap.EpilepsyWarning = Parsing.ParseInt(pair.Value) == 1;
                     break;
 
                 case @"SamplesMatchPlaybackRate":
-                    beatmap.BeatmapInfo.SamplesMatchPlaybackRate = Parsing.ParseInt(pair.Value) == 1;
+                    beatmap.SamplesMatchPlaybackRate = Parsing.ParseInt(pair.Value) == 1;
                     break;
 
                 case @"Countdown":
-                    beatmap.BeatmapInfo.Countdown = Enum.Parse<CountdownType>(pair.Value);
+                    beatmap.Countdown = Enum.Parse<CountdownType>(pair.Value);
                     break;
 
                 case @"CountdownOffset":
-                    beatmap.BeatmapInfo.CountdownOffset = Parsing.ParseInt(pair.Value);
+                    beatmap.CountdownOffset = Parsing.ParseInt(pair.Value);
                     break;
             }
         }
@@ -313,7 +313,7 @@ namespace osu.Game.Beatmaps.Formats
                     break;
 
                 case @"DistanceSpacing":
-                    beatmap.BeatmapInfo.DistanceSpacing = Math.Max(0, Parsing.ParseDouble(pair.Value));
+                    beatmap.DistanceSpacing = Math.Max(0, Parsing.ParseDouble(pair.Value));
                     break;
 
                 case @"BeatDivisor":
@@ -321,11 +321,11 @@ namespace osu.Game.Beatmaps.Formats
                     break;
 
                 case @"GridSize":
-                    beatmap.BeatmapInfo.GridSize = Parsing.ParseInt(pair.Value);
+                    beatmap.GridSize = Parsing.ParseInt(pair.Value);
                     break;
 
                 case @"TimelineZoom":
-                    beatmap.BeatmapInfo.TimelineZoom = Math.Max(0, Parsing.ParseDouble(pair.Value));
+                    beatmap.TimelineZoom = Math.Max(0, Parsing.ParseDouble(pair.Value));
                     break;
             }
         }

osu.Game/Beatmaps/Formats/LegacyBeatmapEncoder.cs

@@ -79,14 +79,14 @@ namespace osu.Game.Beatmaps.Formats
             writer.WriteLine("[General]");
 
             if (!string.IsNullOrEmpty(beatmap.Metadata.AudioFile)) writer.WriteLine(FormattableString.Invariant($"AudioFilename: {Path.GetFileName(beatmap.Metadata.AudioFile)}"));
-            writer.WriteLine(FormattableString.Invariant($"AudioLeadIn: {beatmap.BeatmapInfo.AudioLeadIn}"));
+            writer.WriteLine(FormattableString.Invariant($"AudioLeadIn: {beatmap.AudioLeadIn}"));
             writer.WriteLine(FormattableString.Invariant($"PreviewTime: {beatmap.Metadata.PreviewTime}"));
-            writer.WriteLine(FormattableString.Invariant($"Countdown: {(int)beatmap.BeatmapInfo.Countdown}"));
+            writer.WriteLine(FormattableString.Invariant($"Countdown: {(int)beatmap.Countdown}"));
             writer.WriteLine(FormattableString.Invariant(
                 $"SampleSet: {toLegacySampleBank(((beatmap.ControlPointInfo as LegacyControlPointInfo)?.SamplePoints.FirstOrDefault() ?? SampleControlPoint.DEFAULT).SampleBank)}"));
-            writer.WriteLine(FormattableString.Invariant($"StackLeniency: {beatmap.BeatmapInfo.StackLeniency}"));
+            writer.WriteLine(FormattableString.Invariant($"StackLeniency: {beatmap.StackLeniency}"));
             writer.WriteLine(FormattableString.Invariant($"Mode: {onlineRulesetID}"));
-            writer.WriteLine(FormattableString.Invariant($"LetterboxInBreaks: {(beatmap.BeatmapInfo.LetterboxInBreaks ? '1' : '0')}"));
+            writer.WriteLine(FormattableString.Invariant($"LetterboxInBreaks: {(beatmap.LetterboxInBreaks ? '1' : '0')}"));
             // if (beatmap.BeatmapInfo.UseSkinSprites)
             //     writer.WriteLine(@"UseSkinSprites: 1");
             // if (b.AlwaysShowPlayfield)
@@ -95,14 +95,14 @@ namespace osu.Game.Beatmaps.Formats
             //     writer.WriteLine(@"OverlayPosition: " + b.OverlayPosition);
             // if (!string.IsNullOrEmpty(b.SkinPreference))
             //     writer.WriteLine(@"SkinPreference:" + b.SkinPreference);
-            if (beatmap.BeatmapInfo.EpilepsyWarning)
+            if (beatmap.EpilepsyWarning)
                 writer.WriteLine(@"EpilepsyWarning: 1");
-            if (beatmap.BeatmapInfo.CountdownOffset > 0)
-                writer.WriteLine(FormattableString.Invariant($@"CountdownOffset: {beatmap.BeatmapInfo.CountdownOffset}"));
+            if (beatmap.CountdownOffset > 0)
+                writer.WriteLine(FormattableString.Invariant($@"CountdownOffset: {beatmap.CountdownOffset}"));
             if (onlineRulesetID == 3)
-                writer.WriteLine(FormattableString.Invariant($"SpecialStyle: {(beatmap.BeatmapInfo.SpecialStyle ? '1' : '0')}"));
-            writer.WriteLine(FormattableString.Invariant($"WidescreenStoryboard: {(beatmap.BeatmapInfo.WidescreenStoryboard ? '1' : '0')}"));
-            if (beatmap.BeatmapInfo.SamplesMatchPlaybackRate)
+                writer.WriteLine(FormattableString.Invariant($"SpecialStyle: {(beatmap.SpecialStyle ? '1' : '0')}"));
+            writer.WriteLine(FormattableString.Invariant($"WidescreenStoryboard: {(beatmap.WidescreenStoryboard ? '1' : '0')}"));
+            if (beatmap.SamplesMatchPlaybackRate)
                 writer.WriteLine(@"SamplesMatchPlaybackRate: 1");
         }
 
@@ -112,10 +112,10 @@ namespace osu.Game.Beatmaps.Formats
 
             if (beatmap.BeatmapInfo.Bookmarks.Length > 0)
                 writer.WriteLine(FormattableString.Invariant($"Bookmarks: {string.Join(',', beatmap.BeatmapInfo.Bookmarks)}"));
-            writer.WriteLine(FormattableString.Invariant($"DistanceSpacing: {beatmap.BeatmapInfo.DistanceSpacing}"));
+            writer.WriteLine(FormattableString.Invariant($"DistanceSpacing: {beatmap.DistanceSpacing}"));
             writer.WriteLine(FormattableString.Invariant($"BeatDivisor: {beatmap.BeatmapInfo.BeatDivisor}"));
-            writer.WriteLine(FormattableString.Invariant($"GridSize: {beatmap.BeatmapInfo.GridSize}"));
-            writer.WriteLine(FormattableString.Invariant($"TimelineZoom: {beatmap.BeatmapInfo.TimelineZoom}"));
+            writer.WriteLine(FormattableString.Invariant($"GridSize: {beatmap.GridSize}"));
+            writer.WriteLine(FormattableString.Invariant($"TimelineZoom: {beatmap.TimelineZoom}"));
         }
 
         private void handleMetadata(TextWriter writer)

osu.Game/Beatmaps/Formats/LegacyStoryboardDecoder.cs

@@ -38,6 +38,17 @@ namespace osu.Game.Beatmaps.Formats
             SetFallbackDecoder<Storyboard>(() => new LegacyStoryboardDecoder());
         }
 
+        protected override Storyboard CreateTemplateObject()
+        {
+            var sb = base.CreateTemplateObject();
+
+            var beatmap = new Beatmap();
+            LegacyBeatmapDecoder.ApplyLegacyDefaults(beatmap);
+            sb.Beatmap = beatmap;
+
+            return sb;
+        }
+
         protected override void ParseStreamInto(LineBufferedReader stream, Storyboard storyboard)
         {
             this.storyboard = storyboard;
@@ -73,6 +84,10 @@ namespace osu.Game.Beatmaps.Formats
                 case "UseSkinSprites":
                     storyboard.UseSkinSprites = pair.Value == "1";
                     break;
+
+                case @"WidescreenStoryboard":
+                    storyboard.Beatmap.WidescreenStoryboard = Parsing.ParseInt(pair.Value) == 1;
+                    break;
             }
         }
 

osu.Game/Beatmaps/IBeatmap.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using osu.Framework.Lists;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Beatmaps.Timing;
+using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Scoring;
 
@@ -69,6 +70,43 @@ namespace osu.Game.Beatmaps
         /// </summary>
         double GetMostCommonBeatLength();
 
+        double AudioLeadIn { get; internal set; }
+
+        float StackLeniency { get; internal set; }
+
+        bool SpecialStyle { get; internal set; }
+
+        bool LetterboxInBreaks { get; internal set; }
+
+        bool WidescreenStoryboard { get; internal set; }
+
+        bool EpilepsyWarning { get; internal set; }
+
+        bool SamplesMatchPlaybackRate { get; internal set; }
+
+        /// <summary>
+        /// The ratio of distance travelled per time unit.
+        /// Generally used to decouple the spacing between hit objects from the enforced "velocity" of the beatmap (see <see cref="DifficultyControlPoint.SliderVelocity"/>).
+        /// </summary>
+        /// <remarks>
+        /// The most common method of understanding is that at a default value of 1.0, the time-to-distance ratio will match the slider velocity of the beatmap
+        /// at the current point in time. Increasing this value will make hit objects more spaced apart when compared to the cursor movement required to track a slider.
+        ///
+        /// This is only a hint property, used by the editor in <see cref="IDistanceSnapProvider"/> implementations. It does not directly affect the beatmap or gameplay.
+        /// </remarks>
+        double DistanceSpacing { get; internal set; }
+
+        int GridSize { get; internal set; }
+
+        double TimelineZoom { get; internal set; }
+
+        CountdownType Countdown { get; internal set; }
+
+        /// <summary>
+        /// The number of beats to move the countdown backwards (compared to its default location).
+        /// </summary>
+        int CountdownOffset { get; internal set; }
+
         /// <summary>
         /// Creates a shallow-clone of this beatmap and returns it.
         /// </summary>

osu.Game/Beatmaps/WorkingBeatmap.cs

@@ -62,7 +62,12 @@ namespace osu.Game.Beatmaps
         #region Resource getters
 
         protected virtual Waveform GetWaveform() => new Waveform(null);
-        protected virtual Storyboard GetStoryboard() => new Storyboard { BeatmapInfo = BeatmapInfo };
+
+        protected virtual Storyboard GetStoryboard() => new Storyboard
+        {
+            BeatmapInfo = BeatmapInfo,
+            Beatmap = Beatmap,
+        };
 
         protected abstract IBeatmap GetBeatmap();
         public abstract Texture GetBackground();

osu.Game/Database/RealmAccess.cs

@@ -94,8 +94,9 @@ namespace osu.Game.Database
         /// 41   2024-04-17    Add ScoreInfo.TotalScoreWithoutMods for future mod multiplier rebalances.
         /// 42   2024-08-07    Update mania key bindings to reflect changes to ManiaAction
         /// 43   2024-10-14    Reset keybind for toggling FPS display to avoid conflict with "convert to stream" in the editor, if not already changed by user.
+        /// 44   2024-11-22    Removed several properties from BeatmapInfo which did not need to be persisted to realm.
         /// </summary>
-        private const int schema_version = 43;
+        private const int schema_version = 44;
 
         /// <summary>
         /// Lock object which is held during <see cref="BlockAllOperations"/> sections, blocking realm retrieval during blocking periods.

osu.Game/OsuGame.cs

@@ -174,6 +174,11 @@ namespace osu.Game
         /// </summary>
         public readonly IBindable<OverlayActivation> OverlayActivationMode = new Bindable<OverlayActivation>();
 
+        /// <summary>
+        /// Whether the back button is currently displayed.
+        /// </summary>
+        private readonly IBindable<bool> backButtonVisibility = new Bindable<bool>();
+
         IBindable<LocalUserPlayingState> ILocalUserPlayInfo.PlayingState => playingState;
 
         private readonly Bindable<LocalUserPlayingState> playingState = new Bindable<LocalUserPlayingState>();
@@ -1019,7 +1024,7 @@ namespace osu.Game
                                             if (!(ScreenStack.CurrentScreen is IOsuScreen currentScreen))
                                                 return;
 
-                                            if (!((Drawable)currentScreen).IsLoaded || (currentScreen.AllowBackButton && !currentScreen.OnBackButton()))
+                                            if (!((Drawable)currentScreen).IsLoaded || (currentScreen.AllowUserExit && !currentScreen.OnBackButton()))
                                                 ScreenStack.Exit();
                                         }
                                     },
@@ -1189,6 +1194,14 @@ namespace osu.Game
                 if (mode.NewValue != OverlayActivation.All) CloseAllOverlays();
             };
 
+            backButtonVisibility.ValueChanged += visible =>
+            {
+                if (visible.NewValue)
+                    BackButton.Show();
+                else
+                    BackButton.Hide();
+            };
+
             // Importantly, this should be run after binding PostNotification to the import handlers so they can present the import after game startup.
             handleStartupImport();
         }
@@ -1581,12 +1594,14 @@ namespace osu.Game
 
             if (current is IOsuScreen currentOsuScreen)
             {
+                backButtonVisibility.UnbindFrom(currentOsuScreen.BackButtonVisibility);
                 OverlayActivationMode.UnbindFrom(currentOsuScreen.OverlayActivationMode);
                 API.Activity.UnbindFrom(currentOsuScreen.Activity);
             }
 
             if (newScreen is IOsuScreen newOsuScreen)
             {
+                backButtonVisibility.BindTo(newOsuScreen.BackButtonVisibility);
                 OverlayActivationMode.BindTo(newOsuScreen.OverlayActivationMode);
                 API.Activity.BindTo(newOsuScreen.Activity);
 
@@ -1597,11 +1612,6 @@ namespace osu.Game
                 else
                     Toolbar.Show();
 
-                if (newOsuScreen.AllowBackButton)
-                    BackButton.Show();
-                else
-                    BackButton.Hide();
-
                 if (newOsuScreen.ShowFooter)
                 {
                     BackButton.Hide();

osu.Game/Overlays/Settings/Sections/Maintenance/MigrationRunScreen.cs

@@ -26,7 +26,7 @@ namespace osu.Game.Overlays.Settings.Sections.Maintenance
         [Resolved(canBeNull: true)]
         private OsuGame game { get; set; }
 
-        public override bool AllowBackButton => false;
+        public override bool AllowUserExit => false;
 
         public override bool AllowExternalScreenChange => false;
 

osu.Game/Overlays/SettingsToolboxGroup.cs

@@ -184,7 +184,7 @@ namespace osu.Game.Overlays
                 content.ResizeHeightTo(0, animate ? transition_duration : 0, Easing.OutQuint);
             }
 
-            headerContent.FadeColour(Expanded.Value ? Color4.White : OsuColour.Gray(0.5f), 200, Easing.OutQuint);
+            headerContent.FadeColour(Expanded.Value ? Color4.White : OsuColour.Gray(0.7f), 200, Easing.OutQuint);
         }
 
         private void updateFadeState()

osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs

@@ -341,6 +341,78 @@ namespace osu.Game.Rulesets.Difficulty
             public double GetMostCommonBeatLength() => baseBeatmap.GetMostCommonBeatLength();
             public IBeatmap Clone() => new ProgressiveCalculationBeatmap(baseBeatmap.Clone());
 
+            public double AudioLeadIn
+            {
+                get => baseBeatmap.AudioLeadIn;
+                set => baseBeatmap.AudioLeadIn = value;
+            }
+
+            public float StackLeniency
+            {
+                get => baseBeatmap.StackLeniency;
+                set => baseBeatmap.StackLeniency = value;
+            }
+
+            public bool SpecialStyle
+            {
+                get => baseBeatmap.SpecialStyle;
+                set => baseBeatmap.SpecialStyle = value;
+            }
+
+            public bool LetterboxInBreaks
+            {
+                get => baseBeatmap.LetterboxInBreaks;
+                set => baseBeatmap.LetterboxInBreaks = value;
+            }
+
+            public bool WidescreenStoryboard
+            {
+                get => baseBeatmap.WidescreenStoryboard;
+                set => baseBeatmap.WidescreenStoryboard = value;
+            }
+
+            public bool EpilepsyWarning
+            {
+                get => baseBeatmap.EpilepsyWarning;
+                set => baseBeatmap.EpilepsyWarning = value;
+            }
+
+            public bool SamplesMatchPlaybackRate
+            {
+                get => baseBeatmap.SamplesMatchPlaybackRate;
+                set => baseBeatmap.SamplesMatchPlaybackRate = value;
+            }
+
+            public double DistanceSpacing
+            {
+                get => baseBeatmap.DistanceSpacing;
+                set => baseBeatmap.DistanceSpacing = value;
+            }
+
+            public int GridSize
+            {
+                get => baseBeatmap.GridSize;
+                set => baseBeatmap.GridSize = value;
+            }
+
+            public double TimelineZoom
+            {
+                get => baseBeatmap.TimelineZoom;
+                set => baseBeatmap.TimelineZoom = value;
+            }
+
+            public CountdownType Countdown
+            {
+                get => baseBeatmap.Countdown;
+                set => baseBeatmap.Countdown = value;
+            }
+
+            public int CountdownOffset
+            {
+                get => baseBeatmap.CountdownOffset;
+                set => baseBeatmap.CountdownOffset = value;
+            }
+
             #endregion
         }
     }

osu.Game/Rulesets/Edit/ComposerDistanceSnapProvider.cs

@@ -100,7 +100,7 @@ namespace osu.Game.Rulesets.Edit
                 }
             });
 
-            DistanceSpacingMultiplier.Value = editorBeatmap.BeatmapInfo.DistanceSpacing;
+            DistanceSpacingMultiplier.Value = editorBeatmap.DistanceSpacing;
             DistanceSpacingMultiplier.BindValueChanged(multiplier =>
             {
                 distanceSpacingSlider.ContractedLabelText = $"D. S. ({multiplier.NewValue:0.##x})";
@@ -109,7 +109,7 @@ namespace osu.Game.Rulesets.Edit
                 if (multiplier.NewValue != multiplier.OldValue)
                     onScreenDisplay?.Display(new DistanceSpacingToast(multiplier.NewValue.ToLocalisableString(@"0.##x"), multiplier));
 
-                editorBeatmap.BeatmapInfo.DistanceSpacing = multiplier.NewValue;
+                editorBeatmap.DistanceSpacing = multiplier.NewValue;
             }, true);
 
             DistanceSpacingMultiplier.BindDisabledChanged(disabled => distanceSpacingSlider.Alpha = disabled ? 0 : 1, true);

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -28,6 +28,7 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Screens.Edit;
+using osu.Game.Screens.Edit.Changes;
 using osu.Game.Screens.Edit.Components.RadioButtons;
 using osu.Game.Screens.Edit.Components.TernaryButtons;
 using osu.Game.Screens.Edit.Compose;
@@ -67,6 +68,9 @@ namespace osu.Game.Rulesets.Edit
         [Resolved]
         private OverlayColourProvider colourProvider { get; set; }
 
+        [Resolved(canBeNull: true)]
+        private NewBeatmapEditorChangeHandler changeHandler { get; set; }
+
         public override ComposeBlueprintContainer BlueprintContainer => blueprintContainer;
         private ComposeBlueprintContainer blueprintContainer;
 
@@ -272,7 +276,8 @@ namespace osu.Game.Rulesets.Edit
             TernaryStates = CreateTernaryButtons().ToArray();
             togglesCollection.AddRange(TernaryStates.Select(b => new DrawableTernaryButton(b)));
 
-            sampleBankTogglesCollection.AddRange(BlueprintContainer.SampleBankTernaryStates.Zip(BlueprintContainer.SampleAdditionBankTernaryStates).Select(b => new SampleBankTernaryButton(b.First, b.Second)));
+            sampleBankTogglesCollection.AddRange(BlueprintContainer.SampleBankTernaryStates.Zip(BlueprintContainer.SampleAdditionBankTernaryStates)
+                                                                   .Select(b => new SampleBankTernaryButton(b.First, b.Second)));
 
             SetSelectTool();
 
@@ -550,13 +555,13 @@ namespace osu.Game.Rulesets.Edit
         public void CommitPlacement(HitObject hitObject)
         {
             EditorBeatmap.PlacementObject.Value = null;
-            EditorBeatmap.Add(hitObject);
+            new AddHitObjectChange(EditorBeatmap, hitObject).Apply(changeHandler);
 
             if (autoSeekOnPlacement.Value && EditorClock.CurrentTime < hitObject.StartTime)
                 EditorClock.SeekSmoothlyTo(hitObject.StartTime);
         }
 
-        public void Delete(HitObject hitObject) => EditorBeatmap.Remove(hitObject);
+        public void Delete(HitObject hitObject) => new RemoveHitObjectChange(EditorBeatmap, hitObject).Apply(changeHandler);
 
         #endregion
 

osu.Game/Rulesets/Edit/IDistanceSnapProvider.cs

@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Edit
         /// A multiplier which changes the ratio of distance travelled per time unit.
         /// Importantly, this is provided for manual usage, and not multiplied into any of the methods exposed by this interface.
         /// </summary>
-        /// <seealso cref="BeatmapInfo.DistanceSpacing"/>
+        /// <seealso cref="IBeatmap.DistanceSpacing"/>
         Bindable<double> DistanceSpacingMultiplier { get; }
 
         /// <summary>

osu.Game/Screens/Edit/Changes/AddHitObjectChange.cs

@@ -0,0 +1,24 @@
+// 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.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    public class AddHitObjectChange : IRevertibleChange
+    {
+        public EditorBeatmap Beatmap;
+
+        public HitObject HitObject;
+
+        public AddHitObjectChange(EditorBeatmap beatmap, HitObject hitObject)
+        {
+            Beatmap = beatmap;
+            HitObject = hitObject;
+        }
+
+        public void Apply() => Beatmap.Add(HitObject);
+
+        public void Revert() => Beatmap.Remove(HitObject);
+    }
+}

osu.Game/Screens/Edit/Changes/AddRangePathControlPointChange.cs

@@ -0,0 +1,30 @@
+// 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 osu.Framework.Bindables;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    /// <summary>
+    /// Adds a range of <see cref="PathControlPoint"/>s to the provided <see cref="BindableList{T}"/>.
+    /// </summary>
+    public class AddRangePathControlPointChange : CompositeChange
+    {
+        private readonly BindableList<PathControlPoint> controlPoints;
+        private readonly IEnumerable<PathControlPoint> points;
+
+        public AddRangePathControlPointChange(BindableList<PathControlPoint> controlPoints, IEnumerable<PathControlPoint> points)
+        {
+            this.controlPoints = controlPoints;
+            this.points = points;
+        }
+
+        protected override void SubmitChanges()
+        {
+            foreach (var point in points)
+                Submit(new InsertPathControlPointChange(controlPoints, controlPoints.Count, point));
+        }
+    }
+}

osu.Game/Screens/Edit/Changes/CompositeChange.cs

@@ -0,0 +1,46 @@
+// 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;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    public abstract class CompositeChange : IRevertibleChange
+    {
+        private List<IRevertibleChange>? changes;
+
+        public void Apply()
+        {
+            if (changes == null)
+            {
+                changes = new List<IRevertibleChange>();
+                SubmitChanges();
+                return;
+            }
+
+            foreach (var change in changes)
+                change.Apply();
+        }
+
+        public void Revert()
+        {
+            if (changes == null)
+                throw new System.InvalidOperationException("Cannot revert before applying.");
+
+            for (int i = changes.Count - 1; i >= 0; i--)
+                changes[i].Revert();
+        }
+
+        protected void Submit(IRevertibleChange change)
+        {
+            change.Apply();
+            changes!.Add(change);
+        }
+
+        /// <summary>
+        /// Applies the tracks the changes of this <see cref="CompositeChange"/>.
+        /// </summary>
+        /// <remarks>Use <see cref="Submit"/> to apply the <see cref="IRevertibleChange"/> created in this method.</remarks>
+        protected abstract void SubmitChanges();
+    }
+}

osu.Game/Screens/Edit/Changes/ExpectedDistanceChange.cs

@@ -0,0 +1,19 @@
+// 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.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    public class ExpectedDistanceChange : PropertyChange<SliderPath, double?>
+    {
+        public ExpectedDistanceChange(SliderPath target, double? value)
+            : base(target, value)
+        {
+        }
+
+        protected override double? ReadValue(SliderPath target) => target.ExpectedDistance.Value;
+
+        protected override void WriteValue(SliderPath target, double? value) => target.ExpectedDistance.Value = value;
+    }
+}

osu.Game/Screens/Edit/Changes/IRevertibleChange.cs

@@ -0,0 +1,32 @@
+// 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.
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    /// <summary>
+    /// Represents a change which can be undone.
+    /// </summary>
+    public interface IRevertibleChange
+    {
+        /// <summary>
+        /// Applies this change to the current state.
+        /// </summary>
+        void Apply();
+
+        /// <summary>
+        /// Applies the inverse of this change to the current state.
+        /// </summary>
+        void Revert();
+    }
+
+    public static class RevertibleChangeExtension
+    {
+        public static void Apply(this IRevertibleChange change, NewBeatmapEditorChangeHandler? changeHandler, bool commitImmediately = false)
+        {
+            if (changeHandler != null)
+                changeHandler.Submit(change, commitImmediately);
+            else
+                change.Apply();
+        }
+    }
+}

osu.Game/Screens/Edit/Changes/InsertPathControlPointChange.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 System.Collections.Generic;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    public class InsertPathControlPointChange : IRevertibleChange
+    {
+        public readonly IList<PathControlPoint> Target;
+
+        public readonly int InsertionIndex;
+
+        public readonly PathControlPoint Item;
+
+        public InsertPathControlPointChange(IList<PathControlPoint> target, int insertionIndex, PathControlPoint item)
+        {
+            Target = target;
+            InsertionIndex = insertionIndex;
+            Item = item;
+        }
+
+        public void Apply() => Target.Insert(InsertionIndex, Item);
+
+        public void Revert() => Target.RemoveAt(InsertionIndex);
+    }
+}

osu.Game/Screens/Edit/Changes/NewComboChange.cs

@@ -0,0 +1,19 @@
+// 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.Rulesets.Objects.Types;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    public class NewComboChange : PropertyChange<IHasComboInformation, bool>
+    {
+        public NewComboChange(IHasComboInformation target, bool value)
+            : base(target, value)
+        {
+        }
+
+        protected override bool ReadValue(IHasComboInformation target) => target.NewCombo;
+
+        protected override void WriteValue(IHasComboInformation target, bool value) => target.NewCombo = value;
+    }
+}

osu.Game/Screens/Edit/Changes/PathControlPointPositionChange.cs

@@ -0,0 +1,20 @@
+// 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.Rulesets.Objects;
+using osuTK;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    public class PathControlPointPositionChange : PropertyChange<PathControlPoint, Vector2>
+    {
+        public PathControlPointPositionChange(PathControlPoint target, Vector2 value)
+            : base(target, value)
+        {
+        }
+
+        protected override Vector2 ReadValue(PathControlPoint target) => target.Position;
+
+        protected override void WriteValue(PathControlPoint target, Vector2 value) => target.Position = value;
+    }
+}

osu.Game/Screens/Edit/Changes/PathControlPointTypeChange.cs

@@ -0,0 +1,20 @@
+// 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.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    public class PathControlPointTypeChange : PropertyChange<PathControlPoint, PathType?>
+    {
+        public PathControlPointTypeChange(PathControlPoint target, PathType? value)
+            : base(target, value)
+        {
+        }
+
+        protected override PathType? ReadValue(PathControlPoint target) => target.Type;
+
+        protected override void WriteValue(PathControlPoint target, PathType? value) => target.Type = value;
+    }
+}

osu.Game/Screens/Edit/Changes/PropertyChange.cs

@@ -0,0 +1,49 @@
+// 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.
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    /// <summary>
+    /// Represents a single property update on a given <see cref="Target"/>.
+    /// </summary>
+    /// <typeparam name="TTarget">Type of the object owning the property</typeparam>
+    /// <typeparam name="TValue">Type of the property to update</typeparam>
+    public abstract class PropertyChange<TTarget, TValue> : IRevertibleChange where TTarget : class
+    {
+        /// <summary>
+        /// Reads the current value of the property from the target.
+        /// </summary>
+        protected abstract TValue ReadValue(TTarget target);
+
+        /// <summary>
+        /// Writes the new value to the target object.
+        /// </summary>
+        protected abstract void WriteValue(TTarget target, TValue value);
+
+        /// <summary>
+        /// The target object, which owns the property to change.
+        /// </summary>
+        public readonly TTarget Target;
+
+        /// <summary>
+        /// The value to change the property to.
+        /// </summary>
+        public readonly TValue Value;
+
+        /// <summary>
+        /// The original value of the property before the change.
+        /// </summary>
+        public readonly TValue OriginalValue;
+
+        protected PropertyChange(TTarget target, TValue value)
+        {
+            Target = target;
+            Value = value;
+            OriginalValue = ReadValue(target);
+        }
+
+        public void Apply() => WriteValue(Target, Value);
+
+        public void Revert() => WriteValue(Target, OriginalValue);
+    }
+}

osu.Game/Screens/Edit/Changes/RemoveHitObjectChange.cs

@@ -0,0 +1,24 @@
+// 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.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    public class RemoveHitObjectChange : IRevertibleChange
+    {
+        public EditorBeatmap Beatmap;
+
+        public HitObject HitObject;
+
+        public RemoveHitObjectChange(EditorBeatmap beatmap, HitObject hitObject)
+        {
+            Beatmap = beatmap;
+            HitObject = hitObject;
+        }
+
+        public void Apply() => Beatmap.Remove(HitObject);
+
+        public void Revert() => Beatmap.Add(HitObject);
+    }
+}

osu.Game/Screens/Edit/Changes/RemovePathControlPointChange.cs

@@ -0,0 +1,35 @@
+// 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 osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    public class RemovePathControlPointChange : IRevertibleChange
+    {
+        public readonly IList<PathControlPoint> Target;
+
+        public readonly int Index;
+
+        public readonly PathControlPoint Item;
+
+        public RemovePathControlPointChange(IList<PathControlPoint> target, int index)
+        {
+            Target = target;
+            Index = index;
+            Item = target[index];
+        }
+
+        public RemovePathControlPointChange(IList<PathControlPoint> target, PathControlPoint item)
+        {
+            Target = target;
+            Index = target.IndexOf(item);
+            Item = item;
+        }
+
+        public void Apply() => Target.RemoveAt(Index);
+
+        public void Revert() => Target.Insert(Index, Item);
+    }
+}

osu.Game/Screens/Edit/Changes/RemoveRangePathControlPointChange.cs

@@ -0,0 +1,31 @@
+// 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.Bindables;
+using osu.Game.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    /// <summary>
+    /// Removes a range of <see cref="PathControlPoint"/>s from the provided <see cref="BindableList{T}"/>.
+    /// </summary>
+    public class RemoveRangePathControlPointChange : CompositeChange
+    {
+        private readonly BindableList<PathControlPoint> controlPoints;
+        private readonly int startIndex;
+        private readonly int count;
+
+        public RemoveRangePathControlPointChange(BindableList<PathControlPoint> controlPoints, int startIndex, int count)
+        {
+            this.controlPoints = controlPoints;
+            this.startIndex = startIndex;
+            this.count = count;
+        }
+
+        protected override void SubmitChanges()
+        {
+            for (int i = 0; i < count; i++)
+                Submit(new RemovePathControlPointChange(controlPoints, startIndex));
+        }
+    }
+}

osu.Game/Screens/Edit/Changes/ReverseSliderPathChange.cs

@@ -3,29 +3,34 @@
 
 using System.Collections.Generic;
 using System.Linq;
-using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osuTK;
 
-namespace osu.Game.Rulesets.Objects
+namespace osu.Game.Screens.Edit.Changes
 {
-    public static class SliderPathExtensions
+    /// <summary>
+    /// Reverse the direction of this path.
+    /// </summary>
+    public class ReverseSliderPathChange : CompositeChange
     {
         /// <summary>
-        /// Snaps the provided <paramref name="hitObject"/>'s duration using the <paramref name="snapProvider"/>.
+        /// The positional offset of the resulting path. It should be added to the start position of the path.
         /// </summary>
-        public static void SnapTo<THitObject>(this THitObject hitObject, IDistanceSnapProvider? snapProvider)
-            where THitObject : HitObject, IHasPath
-        {
-            hitObject.Path.ExpectedDistance.Value = snapProvider?.FindSnappedDistance(hitObject, (float)hitObject.Path.CalculatedDistance, DistanceSnapTarget.Start) ?? hitObject.Path.CalculatedDistance;
-        }
+        public Vector2 PositionalOffset { get; private set; }
+
+        private readonly SliderPath sliderPath;
 
         /// <summary>
         /// Reverse the direction of this path.
         /// </summary>
         /// <param name="sliderPath">The <see cref="SliderPath"/>.</param>
-        /// <param name="positionalOffset">The positional offset of the resulting path. It should be added to the start position of this path.</param>
-        public static void Reverse(this SliderPath sliderPath, out Vector2 positionalOffset)
+        public ReverseSliderPathChange(SliderPath sliderPath)
+        {
+            this.sliderPath = sliderPath;
+        }
+
+        protected override void SubmitChanges()
         {
             var controlPoints = sliderPath.ControlPoints;
 
@@ -33,7 +38,7 @@ namespace osu.Game.Rulesets.Objects
 
             // Inherited points after a linear point, as well as the first control point if it inherited,
             // should be treated as linear points, so their types are temporarily changed to linear.
-            inheritedLinearPoints.ForEach(p => p.Type = PathType.LINEAR);
+            inheritedLinearPoints.ForEach(p => Submit(new PathControlPointTypeChange(p, PathType.LINEAR)));
 
             double[] segmentEnds = sliderPath.GetSegmentEnds().ToArray();
 
@@ -46,11 +51,11 @@ namespace osu.Game.Rulesets.Objects
                     segmentEnds = segmentEnds[..^1];
                 }
 
-                controlPoints.RemoveAt(controlPoints.Count - 1);
+                Submit(new RemovePathControlPointChange(controlPoints, controlPoints.Count - 1));
             }
 
             // Restore original control point types.
-            inheritedLinearPoints.ForEach(p => p.Type = null);
+            inheritedLinearPoints.ForEach(p => Submit(new PathControlPointTypeChange(p, null)));
 
             // Recalculate middle perfect curve control points at the end of the slider path.
             if (controlPoints.Count >= 3 && controlPoints[^3].Type == PathType.PERFECT_CURVE && controlPoints[^2].Type == null && segmentEnds.Any())
@@ -61,30 +66,25 @@ namespace osu.Game.Rulesets.Objects
                 var circleArcPath = new List<Vector2>();
                 sliderPath.GetPathToProgress(circleArcPath, lastSegmentStart / lastSegmentEnd, 1);
 
-                controlPoints[^2].Position = circleArcPath[circleArcPath.Count / 2];
+                Submit(new PathControlPointPositionChange(controlPoints[^2], circleArcPath[circleArcPath.Count / 2]));
             }
 
-            sliderPath.reverseControlPoints(out positionalOffset);
+            reverseControlPoints();
         }
 
-        /// <summary>
-        /// Reverses the order of the provided <see cref="SliderPath"/>'s <see cref="PathControlPoint"/>s.
-        /// </summary>
-        /// <param name="sliderPath">The <see cref="SliderPath"/>.</param>
-        /// <param name="positionalOffset">The positional offset of the resulting path. It should be added to the start position of this path.</param>
-        private static void reverseControlPoints(this SliderPath sliderPath, out Vector2 positionalOffset)
+        private void reverseControlPoints()
         {
             var points = sliderPath.ControlPoints.ToArray();
-            positionalOffset = sliderPath.PositionAt(1);
+            PositionalOffset = sliderPath.PositionAt(1);
 
-            sliderPath.ControlPoints.Clear();
+            Submit(new RemoveRangePathControlPointChange(sliderPath.ControlPoints, 0, sliderPath.ControlPoints.Count));
 
             PathType? lastType = null;
 
             for (int i = 0; i < points.Length; i++)
             {
-                var p = points[i];
-                p.Position -= positionalOffset;
+                var p = new PathControlPoint(points[i].Position, points[i].Type);
+                p.Position -= PositionalOffset;
 
                 // propagate types forwards to last null type
                 if (i == points.Length - 1)
@@ -95,7 +95,7 @@ namespace osu.Game.Rulesets.Objects
                 else if (p.Type != null)
                     (p.Type, lastType) = (lastType, p.Type);
 
-                sliderPath.ControlPoints.Insert(0, p);
+                Submit(new InsertPathControlPointChange(sliderPath.ControlPoints, 0, p));
             }
         }
     }

osu.Game/Screens/Edit/Changes/SliderVelocityMultiplierChange.cs

@@ -0,0 +1,19 @@
+// 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.Rulesets.Objects.Types;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    public class SliderVelocityMultiplierChange : PropertyChange<IHasSliderVelocity, double>
+    {
+        public SliderVelocityMultiplierChange(IHasSliderVelocity target, double value)
+            : base(target, value)
+        {
+        }
+
+        protected override double ReadValue(IHasSliderVelocity target) => target.SliderVelocityMultiplier;
+
+        protected override void WriteValue(IHasSliderVelocity target, double value) => target.SliderVelocityMultiplier = value;
+    }
+}

osu.Game/Screens/Edit/Changes/SnapToChange.cs

@@ -0,0 +1,30 @@
+// 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.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    /// <summary>
+    /// Snaps the provided <see cref="HitObject"/>'s duration using the <see cref="IDistanceSnapProvider"/>.
+    /// </summary>
+    public class SnapToChange<THitObject> : CompositeChange where THitObject : HitObject, IHasPath
+    {
+        private readonly THitObject hitObject;
+        private readonly IDistanceSnapProvider? snapProvider;
+
+        public SnapToChange(THitObject hitObject, IDistanceSnapProvider? snapProvider)
+        {
+            this.hitObject = hitObject;
+            this.snapProvider = snapProvider;
+        }
+
+        protected override void SubmitChanges()
+        {
+            double newDistance = snapProvider?.FindSnappedDistance(hitObject, (float)hitObject.Path.CalculatedDistance, DistanceSnapTarget.Start) ?? hitObject.Path.CalculatedDistance;
+            Submit(new ExpectedDistanceChange(hitObject.Path, newDistance));
+        }
+    }
+}

osu.Game/Screens/Edit/Changes/StartTimeChange.cs

@@ -0,0 +1,19 @@
+// 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.Rulesets.Objects;
+
+namespace osu.Game.Screens.Edit.Changes
+{
+    public class StartTimeChange : PropertyChange<HitObject, double>
+    {
+        public StartTimeChange(HitObject target, double value)
+            : base(target, value)
+        {
+        }
+
+        protected override double ReadValue(HitObject target) => target.StartTime;
+
+        protected override void WriteValue(HitObject target, double value) => target.StartTime = value;
+    }
+}

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

@@ -47,7 +47,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         private IPositionSnapProvider snapProvider { get; set; }
 
         [Resolved(CanBeNull = true)]
-        private IEditorChangeHandler changeHandler { get; set; }
+        private NewBeatmapEditorChangeHandler changeHandler { get; set; }
 
         protected readonly BindableList<T> SelectedItems = new BindableList<T>();
 
@@ -433,7 +433,10 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// Finishes the current blueprint selection.
         /// </summary>
         /// <param name="e">The mouse event which triggered end of selection.</param>
-        /// <returns>Whether a click selection was active.</returns>
+        /// <returns>
+        /// Whether the mouse event is considered to be fully handled.
+        /// If the return value is <see langword="false"/>, the standard click / mouse up action will follow.
+        /// </returns>
         private bool endClickSelection(MouseButtonEvent e)
         {
             // If already handled a selection, double-click, or drag, we don't want to perform a mouse up / click action.
@@ -443,14 +446,16 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
             if (e.ControlPressed)
             {
-                // if a selection didn't occur, we may want to trigger a deselection.
-
                 // Iterate from the top of the input stack (blueprints closest to the front of the screen first).
                 // Priority is given to already-selected blueprints.
                 foreach (SelectionBlueprint<T> blueprint in SelectionBlueprints.AliveChildren.Where(b => b.IsHovered).OrderByDescending(b => b.IsSelected))
                     return clickSelectionHandled = SelectionHandler.MouseUpSelectionRequested(blueprint, e);
 
-                return false;
+                // can only be reached if there are no hovered blueprints.
+                // in that case, we still want to suppress mouse up / click handling, because when control is pressed,
+                // it is presumed we want to add to existing selection, not remove from it
+                // (unless explicitly control-clicking a selected object, which is handled above).
+                return true;
             }
 
             if (selectedBlueprintAlreadySelectedOnMouseDown && SelectedItems.Count == 1)

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

@@ -14,6 +14,7 @@ using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Screens.Edit.Changes;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
@@ -25,6 +26,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
         [Resolved]
         protected EditorBeatmap Beatmap { get; private set; }
 
+        [Resolved(canBeNull: true)]
+        private NewBeatmapEditorChangeHandler changeHandler { get; set; }
+
         protected readonly HitObjectComposer Composer;
 
         private HitObjectUsageEventBuffer usageEventBuffer;
@@ -87,8 +91,9 @@ namespace osu.Game.Screens.Edit.Compose.Components
                 {
                     Beatmap.PerformOnSelection(obj =>
                     {
-                        obj.StartTime += offset;
+                        new StartTimeChange(obj, obj.StartTime + offset).Apply(changeHandler);
                         Beatmap.Update(obj);
+                        changeHandler?.RecordUpdate(obj);
                     });
                 }
             }
@@ -119,7 +124,10 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
             // handle positional change etc.
             foreach (var blueprint in SelectionBlueprints)
+            {
                 Beatmap.Update(blueprint.Item);
+                changeHandler?.RecordUpdate(blueprint.Item);
+            }
         }
 
         protected override bool OnDoubleClick(DoubleClickEvent e)

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

@@ -52,7 +52,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         protected SelectionBox SelectionBox { get; private set; } = null!;
 
         [Resolved(CanBeNull = true)]
-        protected IEditorChangeHandler? ChangeHandler { get; private set; }
+        protected NewBeatmapEditorChangeHandler? ChangeHandler { get; private set; }
 
         public SelectionRotationHandler RotationHandler { get; private set; } = null!;
 

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

@@ -157,7 +157,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                 Scheduler.AddOnce(applyVisualOffset, beatmap);
             }, true);
 
-            Zoom = (float)(defaultTimelineZoom * editorBeatmap.BeatmapInfo.TimelineZoom);
+            Zoom = (float)(defaultTimelineZoom * editorBeatmap.TimelineZoom);
         }
 
         private void applyVisualOffset(IBindable<WorkingBeatmap> beatmap)
@@ -212,7 +212,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
                 float minimumZoom = getZoomLevelForVisibleMilliseconds(10000);
                 float maximumZoom = getZoomLevelForVisibleMilliseconds(500);
 
-                float initialZoom = (float)Math.Clamp(defaultTimelineZoom * (editorBeatmap.BeatmapInfo.TimelineZoom == 0 ? 1 : editorBeatmap.BeatmapInfo.TimelineZoom), minimumZoom, maximumZoom);
+                float initialZoom = (float)Math.Clamp(defaultTimelineZoom * (editorBeatmap.TimelineZoom == 0 ? 1 : editorBeatmap.TimelineZoom), minimumZoom, maximumZoom);
 
                 SetupZoom(initialZoom, minimumZoom, maximumZoom);
 
@@ -234,7 +234,7 @@ namespace osu.Game.Screens.Edit.Compose.Components.Timeline
         protected override void OnZoomChanged()
         {
             base.OnZoomChanged();
-            editorBeatmap.BeatmapInfo.TimelineZoom = Zoom / defaultTimelineZoom;
+            editorBeatmap.TimelineZoom = Zoom / defaultTimelineZoom;
         }
 
         protected override void UpdateAfterChildren()

osu.Game/Screens/Edit/Editor.cs

@@ -80,8 +80,6 @@ namespace osu.Game.Screens.Edit
 
         public override float BackgroundParallaxAmount => 0.1f;
 
-        public override bool AllowBackButton => false;
-
         public override bool HideOverlaysOnEnter => true;
 
         public override bool DisallowExternalBeatmapRulesetChanges => true;
@@ -179,6 +177,8 @@ namespace osu.Game.Screens.Edit
         [CanBeNull] // Should be non-null once it can support custom rulesets.
         private EditorChangeHandler changeHandler;
 
+        private NewBeatmapEditorChangeHandler newChangeHandler;
+
         private DependencyContainer dependencies;
 
         private bool isNewBeatmap;
@@ -194,6 +194,8 @@ namespace osu.Game.Screens.Edit
             }
         }
 
+        protected override bool InitialBackButtonVisibility => false;
+
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
             => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
@@ -302,6 +304,9 @@ namespace osu.Game.Screens.Edit
                 dependencies.CacheAs<IEditorChangeHandler>(changeHandler);
             }
 
+            newChangeHandler = new NewBeatmapEditorChangeHandler(editorBeatmap);
+            dependencies.CacheAs(newChangeHandler);
+
             beatDivisor.SetArbitraryDivisor(editorBeatmap.BeatmapInfo.BeatDivisor);
             beatDivisor.BindValueChanged(divisor => editorBeatmap.BeatmapInfo.BeatDivisor = divisor.NewValue);
 
@@ -440,8 +445,8 @@ namespace osu.Game.Screens.Edit
                 }
             });
 
-            changeHandler?.CanUndo.BindValueChanged(v => undoMenuItem.Action.Disabled = !v.NewValue, true);
-            changeHandler?.CanRedo.BindValueChanged(v => redoMenuItem.Action.Disabled = !v.NewValue, true);
+            newChangeHandler.CanUndo.BindValueChanged(v => undoMenuItem.Action.Disabled = !v.NewValue, true);
+            newChangeHandler.CanRedo.BindValueChanged(v => redoMenuItem.Action.Disabled = !v.NewValue, true);
 
             editorBackgroundDim.BindValueChanged(_ => dimBackground());
         }
@@ -760,11 +765,6 @@ namespace osu.Game.Screens.Edit
 
             switch (e.Action)
             {
-                case GlobalAction.Back:
-                    // as we don't want to display the back button, manual handling of exit action is required.
-                    this.Exit();
-                    return true;
-
                 case GlobalAction.EditorCloneSelection:
                     Clone();
                     return true;
@@ -976,9 +976,9 @@ namespace osu.Game.Screens.Edit
 
         #endregion
 
-        protected void Undo() => changeHandler?.RestoreState(-1);
+        protected void Undo() => newChangeHandler.Undo();
 
-        protected void Redo() => changeHandler?.RestoreState(1);
+        protected void Redo() => newChangeHandler.Redo();
 
         protected void SetPreviewPointToCurrentTime()
         {

osu.Game/Screens/Edit/EditorBeatmap.cs

@@ -198,6 +198,78 @@ namespace osu.Game.Screens.Edit
 
         public double GetMostCommonBeatLength() => PlayableBeatmap.GetMostCommonBeatLength();
 
+        public double AudioLeadIn
+        {
+            get => PlayableBeatmap.AudioLeadIn;
+            set => PlayableBeatmap.AudioLeadIn = value;
+        }
+
+        public float StackLeniency
+        {
+            get => PlayableBeatmap.StackLeniency;
+            set => PlayableBeatmap.StackLeniency = value;
+        }
+
+        public bool SpecialStyle
+        {
+            get => PlayableBeatmap.SpecialStyle;
+            set => PlayableBeatmap.SpecialStyle = value;
+        }
+
+        public bool LetterboxInBreaks
+        {
+            get => PlayableBeatmap.LetterboxInBreaks;
+            set => PlayableBeatmap.LetterboxInBreaks = value;
+        }
+
+        public bool WidescreenStoryboard
+        {
+            get => PlayableBeatmap.WidescreenStoryboard;
+            set => PlayableBeatmap.WidescreenStoryboard = value;
+        }
+
+        public bool EpilepsyWarning
+        {
+            get => PlayableBeatmap.EpilepsyWarning;
+            set => PlayableBeatmap.EpilepsyWarning = value;
+        }
+
+        public bool SamplesMatchPlaybackRate
+        {
+            get => PlayableBeatmap.SamplesMatchPlaybackRate;
+            set => PlayableBeatmap.SamplesMatchPlaybackRate = value;
+        }
+
+        public double DistanceSpacing
+        {
+            get => PlayableBeatmap.DistanceSpacing;
+            set => PlayableBeatmap.DistanceSpacing = value;
+        }
+
+        public int GridSize
+        {
+            get => PlayableBeatmap.GridSize;
+            set => PlayableBeatmap.GridSize = value;
+        }
+
+        public double TimelineZoom
+        {
+            get => PlayableBeatmap.TimelineZoom;
+            set => PlayableBeatmap.TimelineZoom = value;
+        }
+
+        public CountdownType Countdown
+        {
+            get => PlayableBeatmap.Countdown;
+            set => PlayableBeatmap.Countdown = value;
+        }
+
+        public int CountdownOffset
+        {
+            get => PlayableBeatmap.CountdownOffset;
+            set => PlayableBeatmap.CountdownOffset = value;
+        }
+
         public IBeatmap Clone() => (EditorBeatmap)MemberwiseClone();
 
         private IList mutableHitObjects => (IList)PlayableBeatmap.HitObjects;

osu.Game/Screens/Edit/EditorLoader.cs

@@ -36,7 +36,7 @@ namespace osu.Game.Screens.Edit
 
         public override float BackgroundParallaxAmount => 0.1f;
 
-        public override bool AllowBackButton => false;
+        public override bool AllowUserExit => false;
 
         public override bool HideOverlaysOnEnter => true;
 

osu.Game/Screens/Edit/NewBeatmapEditorChangeHandler.cs

@@ -0,0 +1,206 @@
+// 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.Framework.Bindables;
+using osu.Framework.Logging;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Screens.Edit.Changes;
+
+namespace osu.Game.Screens.Edit
+{
+    public partial class NewBeatmapEditorChangeHandler : TransactionalCommitComponent
+    {
+        private readonly EditorBeatmap editorBeatmap;
+
+        public readonly Bindable<bool> CanUndo = new BindableBool();
+
+        public readonly Bindable<bool> CanRedo = new BindableBool();
+
+        public bool HasUncommittedChanges => currentTransaction.UndoChanges.Count != 0;
+
+        private Transaction currentTransaction;
+
+        private readonly Stack<Transaction> undoStack = new Stack<Transaction>();
+
+        private readonly Stack<Transaction> redoStack = new Stack<Transaction>();
+
+        private bool isRestoring;
+
+        public NewBeatmapEditorChangeHandler(EditorBeatmap editorBeatmap)
+        {
+            currentTransaction = new Transaction();
+            this.editorBeatmap = editorBeatmap;
+
+            editorBeatmap.TransactionBegan += BeginChange;
+            editorBeatmap.TransactionEnded += EndChange;
+            editorBeatmap.SaveStateTriggered += SaveState;
+        }
+
+        /// <summary>
+        /// Submits a change to be applied and added to the history.
+        /// </summary>
+        /// <param name="change">Change to be applied.</param>
+        /// <param name="commitImmediately">Whether to commit the current transaction and push it onto the undo stack immediately.</param>
+        public void Submit(IRevertibleChange change, bool commitImmediately = false)
+        {
+            change.Apply();
+            record(change);
+
+            if (commitImmediately)
+                UpdateState();
+        }
+
+        /// <summary>
+        /// Submits a collection of changes to be applied and added to the history.
+        /// </summary>
+        /// <param name="changes">Changes to be applied.</param>
+        /// <param name="commitImmediately">Whether to commit the current transaction and push it onto the undo stack immediately.</param>
+        public void Submit(IEnumerable<IRevertibleChange> changes, bool commitImmediately = false)
+        {
+            foreach (var change in changes)
+                Submit(change);
+
+            if (commitImmediately)
+                UpdateState();
+        }
+
+        protected override void UpdateState()
+        {
+            if (isRestoring)
+                return;
+
+            if (!HasUncommittedChanges)
+            {
+                Logger.Log("Nothing to commit");
+                return;
+            }
+
+            undoStack.Push(currentTransaction);
+            redoStack.Clear();
+
+            Logger.Log($"Added {currentTransaction.UndoChanges.Count} change(s) to undo stack");
+
+            currentTransaction = new Transaction();
+
+            historyChanged();
+        }
+
+        /// <summary>
+        /// Undoes the last transaction from the undo stack.
+        /// Returns false if there are is nothing to undo.
+        /// </summary>
+        public bool Undo()
+        {
+            if (undoStack.Count == 0)
+                return false;
+
+            var transaction = undoStack.Pop();
+
+            revertTransaction(transaction);
+
+            redoStack.Push(transaction);
+
+            historyChanged();
+
+            return true;
+        }
+
+        /// <summary>
+        /// Redoes the last transaction from the redo stack.
+        /// Returns false if there are is nothing to redo.
+        /// </summary>
+        public bool Redo()
+        {
+            if (redoStack.Count == 0)
+                return false;
+
+            var transaction = redoStack.Pop();
+
+            applyTransaction(transaction);
+
+            undoStack.Push(transaction);
+
+            historyChanged();
+
+            return true;
+        }
+
+        private void revertTransaction(Transaction transaction)
+        {
+            isRestoring = true;
+            editorBeatmap.BeginChange();
+
+            foreach (var change in transaction.UndoChanges.Reverse())
+                change.Revert();
+
+            foreach (var hitObject in transaction.HitObjectUpdates)
+                editorBeatmap.Update(hitObject);
+
+            editorBeatmap.EndChange();
+            isRestoring = false;
+        }
+
+        private void applyTransaction(Transaction transaction)
+        {
+            isRestoring = true;
+            editorBeatmap.BeginChange();
+
+            foreach (var change in transaction.UndoChanges)
+                change.Apply();
+
+            foreach (var hitObject in transaction.HitObjectUpdates)
+                editorBeatmap.Update(hitObject);
+
+            editorBeatmap.EndChange();
+            isRestoring = false;
+        }
+
+        private void historyChanged()
+        {
+            CanUndo.Value = undoStack.Count > 0;
+            CanRedo.Value = redoStack.Count > 0;
+        }
+
+        private void record(IRevertibleChange change)
+        {
+            currentTransaction.Add(change);
+        }
+
+        public void RecordUpdate(HitObject hitObject)
+        {
+            currentTransaction.RecordUpdate(hitObject);
+        }
+
+        private readonly struct Transaction
+        {
+            public Transaction()
+            {
+                undoChanges = new List<IRevertibleChange>();
+            }
+
+            private readonly List<IRevertibleChange> undoChanges;
+
+            private readonly HashSet<HitObject> hitObjectUpdates = new HashSet<HitObject>();
+
+            /// <summary>
+            /// The changes to undo the given transaction.
+            /// Stored in reverse order of original changes to match execution order when undoing.
+            /// </summary>
+            public IReadOnlyList<IRevertibleChange> UndoChanges => undoChanges;
+
+            public IReadOnlySet<HitObject> HitObjectUpdates => hitObjectUpdates;
+
+            public void Add(IRevertibleChange change)
+            {
+                undoChanges.Add(change);
+            }
+
+            public void RecordUpdate(HitObject hitObject)
+            {
+                hitObjectUpdates.Add(hitObject);
+            }
+        }
+    }
+}

osu.Game/Screens/Edit/Setup/DesignSection.cs

@@ -39,7 +39,7 @@ namespace osu.Game.Screens.Edit.Setup
                 {
                     Caption = EditorSetupStrings.EnableCountdown,
                     HintText = EditorSetupStrings.CountdownDescription,
-                    Current = { Value = Beatmap.BeatmapInfo.Countdown != CountdownType.None },
+                    Current = { Value = Beatmap.Countdown != CountdownType.None },
                 },
                 CountdownSettings = new FillFlowContainer
                 {
@@ -52,14 +52,14 @@ namespace osu.Game.Screens.Edit.Setup
                         CountdownSpeed = new FormEnumDropdown<CountdownType>
                         {
                             Caption = EditorSetupStrings.CountdownSpeed,
-                            Current = { Value = Beatmap.BeatmapInfo.Countdown != CountdownType.None ? Beatmap.BeatmapInfo.Countdown : CountdownType.Normal },
+                            Current = { Value = Beatmap.Countdown != CountdownType.None ? Beatmap.Countdown : CountdownType.Normal },
                             Items = Enum.GetValues<CountdownType>().Where(type => type != CountdownType.None)
                         },
                         CountdownOffset = new FormNumberBox
                         {
                             Caption = EditorSetupStrings.CountdownOffset,
                             HintText = EditorSetupStrings.CountdownOffsetDescription,
-                            Current = { Value = Beatmap.BeatmapInfo.CountdownOffset.ToString() },
+                            Current = { Value = Beatmap.CountdownOffset.ToString() },
                             TabbableContentContainer = this,
                         }
                     }
@@ -68,25 +68,25 @@ namespace osu.Game.Screens.Edit.Setup
                 {
                     Caption = EditorSetupStrings.WidescreenSupport,
                     HintText = EditorSetupStrings.WidescreenSupportDescription,
-                    Current = { Value = Beatmap.BeatmapInfo.WidescreenStoryboard }
+                    Current = { Value = Beatmap.WidescreenStoryboard }
                 },
                 epilepsyWarning = new FormCheckBox
                 {
                     Caption = EditorSetupStrings.EpilepsyWarning,
                     HintText = EditorSetupStrings.EpilepsyWarningDescription,
-                    Current = { Value = Beatmap.BeatmapInfo.EpilepsyWarning }
+                    Current = { Value = Beatmap.EpilepsyWarning }
                 },
                 letterboxDuringBreaks = new FormCheckBox
                 {
                     Caption = EditorSetupStrings.LetterboxDuringBreaks,
                     HintText = EditorSetupStrings.LetterboxDuringBreaksDescription,
-                    Current = { Value = Beatmap.BeatmapInfo.LetterboxInBreaks }
+                    Current = { Value = Beatmap.LetterboxInBreaks }
                 },
                 samplesMatchPlaybackRate = new FormCheckBox
                 {
                     Caption = EditorSetupStrings.SamplesMatchPlaybackRate,
                     HintText = EditorSetupStrings.SamplesMatchPlaybackRateDescription,
-                    Current = { Value = Beatmap.BeatmapInfo.SamplesMatchPlaybackRate }
+                    Current = { Value = Beatmap.SamplesMatchPlaybackRate }
                 }
             };
         }
@@ -113,18 +113,18 @@ namespace osu.Game.Screens.Edit.Setup
         {
             updateBeatmap();
             // update displayed text to ensure parsed value matches display (i.e. if empty string was provided).
-            CountdownOffset.Current.Value = Beatmap.BeatmapInfo.CountdownOffset.ToString(CultureInfo.InvariantCulture);
+            CountdownOffset.Current.Value = Beatmap.CountdownOffset.ToString(CultureInfo.InvariantCulture);
         }
 
         private void updateBeatmap()
         {
-            Beatmap.BeatmapInfo.Countdown = EnableCountdown.Current.Value ? CountdownSpeed.Current.Value : CountdownType.None;
-            Beatmap.BeatmapInfo.CountdownOffset = int.TryParse(CountdownOffset.Current.Value, NumberStyles.None, CultureInfo.InvariantCulture, out int offset) ? offset : 0;
+            Beatmap.Countdown = EnableCountdown.Current.Value ? CountdownSpeed.Current.Value : CountdownType.None;
+            Beatmap.CountdownOffset = int.TryParse(CountdownOffset.Current.Value, NumberStyles.None, CultureInfo.InvariantCulture, out int offset) ? offset : 0;
 
-            Beatmap.BeatmapInfo.WidescreenStoryboard = widescreenSupport.Current.Value;
-            Beatmap.BeatmapInfo.EpilepsyWarning = epilepsyWarning.Current.Value;
-            Beatmap.BeatmapInfo.LetterboxInBreaks = letterboxDuringBreaks.Current.Value;
-            Beatmap.BeatmapInfo.SamplesMatchPlaybackRate = samplesMatchPlaybackRate.Current.Value;
+            Beatmap.WidescreenStoryboard = widescreenSupport.Current.Value;
+            Beatmap.EpilepsyWarning = epilepsyWarning.Current.Value;
+            Beatmap.LetterboxInBreaks = letterboxDuringBreaks.Current.Value;
+            Beatmap.SamplesMatchPlaybackRate = samplesMatchPlaybackRate.Current.Value;
 
             Beatmap.SaveState();
         }

osu.Game/Screens/IOsuScreen.cs

@@ -5,6 +5,7 @@ using System.Collections.Generic;
 using osu.Framework.Bindables;
 using osu.Framework.Screens;
 using osu.Game.Beatmaps;
+using osu.Game.Input.Bindings;
 using osu.Game.Overlays;
 using osu.Game.Rulesets;
 using osu.Game.Screens.Footer;
@@ -21,15 +22,21 @@ namespace osu.Game.Screens
         bool DisallowExternalBeatmapRulesetChanges { get; }
 
         /// <summary>
-        /// Whether the user can exit this <see cref="IOsuScreen"/> by pressing the back button.
+        /// Whether the user can exit this <see cref="IOsuScreen"/>.
         /// </summary>
-        bool AllowBackButton { get; }
+        /// <remarks>
+        /// When overriden to <c>false</c>,
+        /// the user is blocked from exiting the screen via the <see cref="GlobalAction.Back"/> action,
+        /// and the back button is hidden from this screen by the initial state of <see cref="BackButtonVisibility"/> being set to hidden.
+        /// </remarks>
+        bool AllowUserExit { get; }
 
         /// <summary>
         /// Whether a footer (and a back button) should be displayed underneath the screen.
         /// </summary>
         /// <remarks>
-        /// Temporarily, the back button is shown regardless of whether <see cref="AllowBackButton"/> is true.
+        /// Temporarily, the footer's own back button is shown regardless of whether <see cref="BackButtonVisibility"/> is set to hidden.
+        /// This will be corrected as the footer becomes used more commonly.
         /// </remarks>
         bool ShowFooter { get; }
 
@@ -59,6 +66,11 @@ namespace osu.Game.Screens
         /// </summary>
         IBindable<OverlayActivation> OverlayActivationMode { get; }
 
+        /// <summary>
+        /// Whether the back button should be displayed in this screen.
+        /// </summary>
+        IBindable<bool> BackButtonVisibility { get; }
+
         /// <summary>
         /// The current <see cref="UserActivity"/> for this screen.
         /// </summary>

osu.Game/Screens/Menu/MainMenu.cs

@@ -48,7 +48,7 @@ namespace osu.Game.Screens.Menu
 
         public override bool HideOverlaysOnEnter => Buttons == null || Buttons.State == ButtonSystemState.Initial;
 
-        public override bool AllowBackButton => false;
+        public override bool AllowUserExit => false;
 
         public override bool AllowExternalScreenChange => true;
 

osu.Game/Screens/OnlinePlay/Multiplayer/Spectate/MultiSpectatorScreen.cs

@@ -126,7 +126,8 @@ namespace osu.Game.Screens.OnlinePlay.Multiplayer.Spectate
                 syncManager = new SpectatorSyncManager(masterClockContainer)
                 {
                     ReadyToStart = performInitialSeek,
-                }
+                },
+                new PlayerSettingsOverlay()
             };
 
             for (int i = 0; i < Users.Count; i++)

osu.Game/Screens/OnlinePlay/OnlinePlayScreen.cs

@@ -180,7 +180,7 @@ namespace osu.Game.Screens.OnlinePlay
             if (!(screenStack.CurrentScreen is IOnlinePlaySubScreen onlineSubScreen))
                 return false;
 
-            if (((Drawable)onlineSubScreen).IsLoaded && onlineSubScreen.AllowBackButton && onlineSubScreen.OnBackButton())
+            if (((Drawable)onlineSubScreen).IsLoaded && onlineSubScreen.AllowUserExit && onlineSubScreen.OnBackButton())
                 return true;
 
             if (screenStack.CurrentScreen != null && !(screenStack.CurrentScreen is LoungeSubScreen))

osu.Game/Screens/OsuScreen.cs

@@ -37,7 +37,7 @@ namespace osu.Game.Screens
 
         public string Description => Title;
 
-        public virtual bool AllowBackButton => true;
+        public virtual bool AllowUserExit => true;
 
         public virtual bool ShowFooter => false;
 
@@ -56,6 +56,15 @@ namespace osu.Game.Screens
 
         IBindable<OverlayActivation> IOsuScreen.OverlayActivationMode => OverlayActivationMode;
 
+        /// <summary>
+        /// The initial visibility state of the back button when this screen is entered for the first time.
+        /// </summary>
+        protected virtual bool InitialBackButtonVisibility => AllowUserExit;
+
+        public readonly Bindable<bool> BackButtonVisibility;
+
+        IBindable<bool> IOsuScreen.BackButtonVisibility => BackButtonVisibility;
+
         public virtual bool CursorVisible => true;
 
         protected new OsuGameBase Game => base.Game as OsuGameBase;
@@ -154,6 +163,7 @@ namespace osu.Game.Screens
             Origin = Anchor.Centre;
 
             OverlayActivationMode = new Bindable<OverlayActivation>(InitialOverlayActivationMode);
+            BackButtonVisibility = new Bindable<bool>(InitialBackButtonVisibility);
         }
 
         [BackgroundDependencyLoader(true)]

osu.Game/Screens/Play/HUD/PlayerSettingsOverlay.cs

@@ -1,46 +1,102 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// 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.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Containers;
-using osuTK;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
 using osu.Game.Screens.Play.PlayerSettings;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Screens.Play.HUD
 {
-    public partial class PlayerSettingsOverlay : VisibilityContainer
+    public partial class PlayerSettingsOverlay : ExpandingContainer
     {
+        public VisualSettings VisualSettings { get; private set; }
+
+        private const float padding = 10;
+
+        public const float EXPANDED_WIDTH = player_settings_width + padding * 2;
+
+        private const float player_settings_width = 270;
+
         private const int fade_duration = 200;
 
-        public readonly VisualSettings VisualSettings;
+        public override void Show() => this.FadeIn(fade_duration);
+        public override void Hide() => this.FadeOut(fade_duration);
+
+        // we'll handle this ourselves because we have slightly custom logic.
+        protected override bool ExpandOnHover => false;
 
         protected override Container<Drawable> Content => content;
 
         private readonly FillFlowContainer content;
 
-        public PlayerSettingsOverlay()
-        {
-            Anchor = Anchor.TopRight;
-            Origin = Anchor.TopRight;
-            AutoSizeAxes = Axes.Both;
+        private readonly IconButton button;
 
-            InternalChild = content = new FillFlowContainer
+        private InputManager inputManager = null!;
+
+        public PlayerSettingsOverlay()
+            : base(0, EXPANDED_WIDTH)
+        {
+            Origin = Anchor.TopRight;
+            Anchor = Anchor.TopRight;
+
+            base.Content.Add(content = new FillFlowContainer
             {
-                Anchor = Anchor.TopRight,
-                Origin = Anchor.TopRight,
                 AutoSizeAxes = Axes.Both,
                 Direction = FillDirection.Vertical,
                 Spacing = new Vector2(0, 20),
+                Margin = new MarginPadding(padding),
                 Children = new PlayerSettingsGroup[]
                 {
                     VisualSettings = new VisualSettings { Expanded = { Value = false } },
                     new AudioSettings { Expanded = { Value = false } }
                 }
-            };
+            });
+
+            AddInternal(button = new IconButton
+            {
+                Icon = FontAwesome.Solid.Cog,
+                Origin = Anchor.TopRight,
+                Anchor = Anchor.TopLeft,
+                Margin = new MarginPadding(5),
+                Action = () => Expanded.Toggle()
+            });
+
+            AddInternal(new Box
+            {
+                Colour = ColourInfo.GradientHorizontal(Color4.Black.Opacity(0), Color4.Black.Opacity(0.8f)),
+                Depth = float.MaxValue,
+                RelativeSizeAxes = Axes.Both,
+            });
         }
 
-        protected override void PopIn() => this.FadeIn(fade_duration);
-        protected override void PopOut() => this.FadeOut(fade_duration);
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            inputManager = GetContainingInputManager()!;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            Expanded.Value = inputManager.CurrentState.Mouse.Position.X >= button.ScreenSpaceDrawQuad.TopLeft.X;
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            // handle un-expanding manually because our children do weird hover blocking stuff.
+        }
 
         public void AddAtStart(PlayerSettingsGroup drawable) => content.Insert(-1, drawable);
     }

osu.Game/Screens/Play/HUDOverlay.cs

@@ -115,6 +115,8 @@ namespace osu.Game.Screens.Play
 
         public HUDOverlay([CanBeNull] DrawableRuleset drawableRuleset, IReadOnlyList<Mod> mods, bool alwaysShowLeaderboard = true)
         {
+            Container rightSettings;
+
             this.drawableRuleset = drawableRuleset;
             this.mods = mods;
 
@@ -146,7 +148,6 @@ namespace osu.Game.Screens.Play
                     Children = new Drawable[]
                     {
                         ModDisplay = CreateModsContainer(),
-                        PlayerSettingsOverlay = CreatePlayerSettingsOverlay(),
                     }
                 },
                 bottomRightElements = new FillFlowContainer
@@ -164,6 +165,14 @@ namespace osu.Game.Screens.Play
                         HoldToQuit = CreateHoldForMenuButton(),
                     }
                 },
+                rightSettings = new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        PlayerSettingsOverlay = new PlayerSettingsOverlay(),
+                    }
+                },
                 LeaderboardFlow = new FillFlowContainer
                 {
                     AutoSizeAxes = Axes.Both,
@@ -173,7 +182,7 @@ namespace osu.Game.Screens.Play
                 },
             };
 
-            hideTargets = new List<Drawable> { mainComponents, topRightElements };
+            hideTargets = new List<Drawable> { mainComponents, topRightElements, rightSettings };
 
             if (rulesetComponents != null)
                 hideTargets.Add(rulesetComponents);
@@ -389,8 +398,6 @@ namespace osu.Game.Screens.Play
             Origin = Anchor.TopRight,
         };
 
-        protected PlayerSettingsOverlay CreatePlayerSettingsOverlay() => new PlayerSettingsOverlay();
-
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
             if (e.Repeat)

osu.Game/Screens/Play/MasterGameplayClockContainer.cs

@@ -95,8 +95,8 @@ namespace osu.Game.Screens.Play
             // some beatmaps specify a current lead-in time which should be used instead of the ruleset-provided value when available.
             // this is not available as an option in the live editor but can still be applied via .osu editing.
             double firstHitObjectTime = beatmap.Beatmap.HitObjects.First().StartTime;
-            if (beatmap.BeatmapInfo.AudioLeadIn > 0)
-                time = Math.Min(time, firstHitObjectTime - beatmap.BeatmapInfo.AudioLeadIn);
+            if (beatmap.Beatmap.AudioLeadIn > 0)
+                time = Math.Min(time, firstHitObjectTime - beatmap.Beatmap.AudioLeadIn);
 
             return time;
         }

osu.Game/Screens/Play/Player.cs

@@ -57,7 +57,7 @@ namespace osu.Game.Screens.Play
         /// </summary>
         public event Action OnGameplayStarted;
 
-        public override bool AllowBackButton => false; // handled by HoldForMenuButton
+        public override bool AllowUserExit => false; // handled by HoldForMenuButton
 
         protected override bool PlayExitSound => !isRestarting;
 
@@ -457,7 +457,7 @@ namespace osu.Game.Screens.Play
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre
                     },
-                    BreakOverlay = new BreakOverlay(working.Beatmap.BeatmapInfo.LetterboxInBreaks, ScoreProcessor)
+                    BreakOverlay = new BreakOverlay(working.Beatmap.LetterboxInBreaks, ScoreProcessor)
                     {
                         Clock = DrawableRuleset.FrameStableClock,
                         ProcessCustomClock = false,

osu.Game/Screens/Play/PlayerLoader.cs

@@ -242,7 +242,7 @@ namespace osu.Game.Screens.Play
                 sampleRestart = new SkinnableSound(new SampleInfo(@"Gameplay/restart", @"pause-retry-click"))
             };
 
-            if (Beatmap.Value.BeatmapInfo.EpilepsyWarning)
+            if (Beatmap.Value.Beatmap.EpilepsyWarning)
             {
                 disclaimers.Add(epilepsyWarning = new PlayerLoaderDisclaimer(PlayerLoaderStrings.EpilepsyWarningTitle, PlayerLoaderStrings.EpilepsyWarningContent));
             }
@@ -485,6 +485,8 @@ namespace osu.Game.Screens.Play
 
             if (quickRestart)
             {
+                BackButtonVisibility.Value = false;
+
                 // A quick restart starts by triggering a fade to black
                 AddInternal(quickRestartBlackLayer = new Box
                 {
@@ -503,6 +505,8 @@ namespace osu.Game.Screens.Play
                     .Delay(quick_restart_initial_delay)
                     .ScaleTo(1)
                     .FadeInFromZero(500, Easing.OutQuint);
+
+                this.Delay(quick_restart_initial_delay).Schedule(() => BackButtonVisibility.Value = true);
             }
             else
             {

osu.Game/Screens/StartupScreen.cs

@@ -10,7 +10,7 @@ namespace osu.Game.Screens
     /// </summary>
     public abstract partial class StartupScreen : OsuScreen
     {
-        public override bool AllowBackButton => false;
+        public override bool AllowUserExit => false;
 
         public override bool HideOverlaysOnEnter => true;
 

osu.Game/Storyboards/Drawables/DrawableStoryboard.cs

@@ -67,7 +67,7 @@ namespace osu.Game.Storyboards.Drawables
 
             bool onlyHasVideoElements = Storyboard.Layers.SelectMany(l => l.Elements).All(e => e is StoryboardVideo);
 
-            Width = Height * (storyboard.BeatmapInfo.WidescreenStoryboard || onlyHasVideoElements ? 16 / 9f : 4 / 3f);
+            Width = Height * (storyboard.Beatmap.WidescreenStoryboard || onlyHasVideoElements ? 16 / 9f : 4 / 3f);
 
             Anchor = Anchor.Centre;
             Origin = Anchor.Centre;

osu.Game/Storyboards/Storyboard.cs

@@ -17,6 +17,7 @@ namespace osu.Game.Storyboards
         public IEnumerable<StoryboardLayer> Layers => layers.Values;
 
         public BeatmapInfo BeatmapInfo = new BeatmapInfo();
+        public IBeatmap Beatmap { get; set; } = new Beatmap();
 
         /// <summary>
         /// Whether the storyboard should prefer textures from the current skin before using local storyboard textures.

osu.Game/Tests/Beatmaps/TestBeatmap.cs

@@ -27,6 +27,17 @@ namespace osu.Game.Tests.Beatmaps
             BeatmapInfo = baseBeatmap.BeatmapInfo;
             ControlPointInfo = baseBeatmap.ControlPointInfo;
             UnhandledEventLines = baseBeatmap.UnhandledEventLines;
+            AudioLeadIn = baseBeatmap.AudioLeadIn;
+            StackLeniency = baseBeatmap.StackLeniency;
+            SpecialStyle = baseBeatmap.SpecialStyle;
+            LetterboxInBreaks = baseBeatmap.LetterboxInBreaks;
+            WidescreenStoryboard = baseBeatmap.WidescreenStoryboard;
+            EpilepsyWarning = baseBeatmap.EpilepsyWarning;
+            SamplesMatchPlaybackRate = baseBeatmap.SamplesMatchPlaybackRate;
+            DistanceSpacing = baseBeatmap.DistanceSpacing;
+            GridSize = baseBeatmap.GridSize;
+            TimelineZoom = baseBeatmap.TimelineZoom;
+            CountdownOffset = baseBeatmap.CountdownOffset;
 
             if (withHitObjects)
             {