Move unnecessary properties from BeatmapInfo / realm to IBeatmap

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

@@ -55,7 +55,7 @@ private void load()
                     Label = "Use special (N+1) style",
                     FixedLabelWidth = LABEL_WIDTH,
                     Description = "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 LabelledSliderBar<float>
                 {
@@ -153,7 +153,7 @@ private void updateValues()
             // 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/TestSceneOsuEditorGrids.cs

@@ -188,6 +188,6 @@ private void nextGridSizeIs(int size)
 
         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);
     }
 }

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

@@ -83,10 +83,7 @@ public void TestSliderDimsOnlyAfterStartTime()
                             })
                         }
                     },
-                    BeatmapInfo =
-                    {
-                        StackLeniency = 0,
-                    }
+                    StackLeniency = 0,
                 },
                 ReplayFrames = new List<ReplayFrame>
                 {

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

@@ -74,12 +74,12 @@ private OsuBeatmap createHitCircleBeatmap(IEnumerable<int> spacings, int objects
             {
                 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 @@ private void performTest(List<ReplayFrame> frames, Action<Slider>? adjustSliderF
         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

@@ -51,13 +51,13 @@ public override void PostProcess()
                     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 void applyStacking(BeatmapInfo beatmapInfo, List<OsuHitObject> hitObjects, int startIndex, int endIndex)
+        private void applyStacking(IBeatmap beatmap, List<OsuHitObject> hitObjects, int startIndex, int endIndex)
         {
             ArgumentOutOfRangeException.ThrowIfGreaterThan(startIndex, endIndex);
             ArgumentOutOfRangeException.ThrowIfNegative(startIndex);
@@ -82,7 +82,7 @@ private void applyStacking(BeatmapInfo beatmapInfo, List<OsuHitObject> hitObject
                             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.
@@ -127,7 +127,7 @@ private void applyStacking(BeatmapInfo beatmapInfo, List<OsuHitObject> hitObject
                 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.
@@ -209,7 +209,7 @@ private void applyStacking(BeatmapInfo beatmapInfo, List<OsuHitObject> hitObject
             }
         }
 
-        private void applyStackingOld(BeatmapInfo beatmapInfo, List<OsuHitObject> hitObjects)
+        private void applyStackingOld(IBeatmap beatmap, List<OsuHitObject> hitObjects)
         {
             for (int i = 0; i < hitObjects.Count; i++)
             {
@@ -223,7 +223,7 @@ private void applyStackingOld(BeatmapInfo beatmapInfo, List<OsuHitObject> hitObj
 
                 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/OsuGridToolboxGroup.cs

@@ -149,7 +149,7 @@ private void load()
                 },
             };
 
-            Spacing.Value = editorBeatmap.BeatmapInfo.GridSize;
+            Spacing.Value = editorBeatmap.GridSize;
         }
 
         protected override void LoadComplete()
@@ -177,7 +177,7 @@ protected override void LoadComplete()
                 spacingSlider.ContractedLabelText = $"S: {spacing.NewValue:N0}";
                 spacingSlider.ExpandedLabelText = $"Spacing: {spacing.NewValue:N0}";
                 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/Setup/OsuDifficultySection.cs

@@ -114,7 +114,7 @@ private void load()
                     Label = "Stack Leniency",
                     FixedLabelWidth = LABEL_WIDTH,
                     Description = "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,
@@ -141,7 +141,7 @@ private void updateValues()
             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 @@ public void TestDecodeBeatmapGeneral()
                 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,21 +101,21 @@ public void TestDecodeBeatmapEditor()
             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 =
                 {
                     11505, 22054, 32604, 43153, 53703, 64252, 74802, 85351,
                     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);
             }
         }
 
@@ -959,15 +959,15 @@ public void TestLegacyDefaultsPreserved(bool applyOffsets)
 
                 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.Normal));
-                    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.Normal));
+                    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 @@ public void TestDecodeGeneral()
         {
             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 @@ public void TestDecodeEditor()
             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 @@ public void TestSubscriptionCollectionAndPropertyChanges()
                 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

@@ -51,7 +51,7 @@ public void TestCountdownOff()
         {
             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);
         }
 
@@ -60,12 +60,12 @@ public void TestCountdownOn()
         {
             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);
         }
 
@@ -74,7 +74,7 @@ public void TestCountdownOffset()
         {
             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);
@@ -94,7 +94,7 @@ private void checkOffsetAfter(string userInput, int expectedFinalValue)
             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 @@ public void TestConfiguration()
             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 @@ public void TestConfiguration()
 
             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]