Merge 4 upstream ppy/osu commits into fork

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

@@ -5,7 +5,6 @@
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Edit.Blueprints;
-using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 
@@ -14,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Edit
     public class BananaShowerCompositionTool : CompositionTool
     {
         public BananaShowerCompositionTool()
-            : base(nameof(BananaShower))
+            : base("Banana shower")
         {
         }
 

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

@@ -5,7 +5,6 @@
 using osu.Framework.Graphics.Sprites;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Catch.Edit.Blueprints;
-using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 
@@ -14,7 +13,7 @@ namespace osu.Game.Rulesets.Catch.Edit
     public class JuiceStreamCompositionTool : CompositionTool
     {
         public JuiceStreamCompositionTool()
-            : base(nameof(JuiceStream))
+            : base("Juice stream")
         {
         }
 

osu.Game.Rulesets.Mania.Tests/ManiaLegacyBeatmapEncoderTest.cs

@@ -36,8 +36,8 @@ public void TestEncodeDecodeStability(string name)
             var decoded = DecodeFromLegacy(beatmaps_resource_store.GetStream($"Resources/Testing/Beatmaps/{name}.osu"), beatmaps_resource_store, name);
             var decodedAfterEncode = DecodeFromLegacy(EncodeToLegacy(decoded), beatmaps_resource_store, name);
 
-            Sort(decoded.beatmap);
-            Sort(decodedAfterEncode.beatmap);
+            Sort(decoded.Beatmap);
+            Sort(decodedAfterEncode.Beatmap);
 
             CompareBeatmaps(decoded, decodedAfterEncode);
         }

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaPlacementBlueprint.cs

@@ -9,6 +9,8 @@
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Skinning.Default;
 using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.UI.Scrolling;
 using System.Numerics;
 using osu.Framework.Input;
@@ -88,5 +90,8 @@ public override SnapResult UpdateTimeAndPosition(Vector2 screenSpacePosition, do
         private float getNoteHeight(Column resultPlayfield) =>
             resultPlayfield.ToScreenSpace(new Vector2(DefaultNotePiece.NOTE_HEIGHT)).Y -
             resultPlayfield.ToScreenSpace(Vector2.Zero).Y;
+
+        public override bool ReplacesExistingObject(HitObject existing)
+            => base.ReplacesExistingObject(existing) && HitObject.Column == ((IHasColumn)existing).Column;
     }
 }

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

@@ -32,7 +32,7 @@ protected override IBeatmap CreateBeatmap(RulesetInfo ruleset)
         [Test]
         public void TestTouchInputPlaceHitCircleDirectly()
         {
-            AddStep("tap circle", () => tap(this.ChildrenOfType<EditorRadioButton>().Single(b => b.Button.Label == "HitCircle")));
+            AddStep("tap circle", () => tap(this.ChildrenOfType<EditorRadioButton>().Single(b => b.Button.Label == "Hit circle")));
 
             AddStep("tap to place circle", () => tap(this.ChildrenOfType<Playfield>().Single()));
             AddAssert("circle placed correctly", () =>
@@ -51,7 +51,7 @@ public void TestTouchInputPlaceHitCircleDirectly()
         [Test]
         public void TestTouchInputPlaceCircleAfterTouchingComposeArea()
         {
-            AddStep("tap circle", () => tap(this.ChildrenOfType<EditorRadioButton>().Single(b => b.Button.Label == "HitCircle")));
+            AddStep("tap circle", () => tap(this.ChildrenOfType<EditorRadioButton>().Single(b => b.Button.Label == "Hit circle")));
 
             AddStep("tap playfield", () => tap(this.ChildrenOfType<Playfield>().Single()));
             AddAssert("circle placed", () => EditorBeatmap.HitObjects.Single(h => h.StartTime == EditorClock.CurrentTimeAccurate) is HitCircle);

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

@@ -792,7 +792,7 @@ private void performTest(List<OsuHitObject> hitObjects, List<ReplayFrame> frames
             {
                 AddStep("export beatmap", () =>
                 {
-                    var beatmapEncoder = new LegacyBeatmapEncoder(playableBeatmap, null);
+                    var beatmapEncoder = new LegacyBeatmapEncoder(playableBeatmap, null, null);
 
                     using (var stream = File.Open(Path.Combine(exportLocation, $"{testCaseName}.osu"), FileMode.Create))
                     {

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

@@ -7,14 +7,13 @@
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
-using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Edit
 {
     public class HitCircleCompositionTool : CompositionTool
     {
         public HitCircleCompositionTool()
-            : base(nameof(HitCircle))
+            : base("Hit circle")
         {
         }
 

osu.Game.Rulesets.Taiko.Tests/TestSceneTaikoPlayerScroller.cs

@@ -27,7 +27,7 @@ public void TestForegroundSpritesHidesScroller()
                 currentStoryboard = new Storyboard();
 
                 for (int i = 0; i < 10; i++)
-                    currentStoryboard.GetLayer("Foreground").Add(new StoryboardSprite($"test{i}", Anchor.Centre, Vector2.Zero));
+                    currentStoryboard.GetLayer("Foreground").Add(new StoryboardSprite(StoryboardElementSource.Beatmap, $"test{i}", Anchor.Centre, Vector2.Zero));
             });
 
             CreateTest();
@@ -42,7 +42,7 @@ public void TestOverlaySpritesKeepsScroller()
                 currentStoryboard = new Storyboard();
 
                 for (int i = 0; i < 10; i++)
-                    currentStoryboard.GetLayer("Overlay").Add(new StoryboardSprite($"test{i}", Anchor.Centre, Vector2.Zero));
+                    currentStoryboard.GetLayer("Overlay").Add(new StoryboardSprite(StoryboardElementSource.Beatmap, $"test{i}", Anchor.Centre, Vector2.Zero));
             });
 
             CreateTest();

osu.Game.Rulesets.Taiko/Edit/DrumRollCompositionTool.cs

@@ -7,14 +7,13 @@
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Taiko.Edit.Blueprints;
-using osu.Game.Rulesets.Taiko.Objects;
 
 namespace osu.Game.Rulesets.Taiko.Edit
 {
     public class DrumRollCompositionTool : CompositionTool
     {
         public DrumRollCompositionTool()
-            : base(nameof(DrumRoll))
+            : base("Drum roll")
         {
         }
 

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

@@ -41,14 +41,14 @@ public class LegacyBeatmapEncoderTest
 
         private static IEnumerable<string> allBeatmaps = beatmaps_resource_store.GetAvailableResources().Where(res => res.EndsWith(".osu", StringComparison.Ordinal));
 
+        public record BeatmapComponents(IBeatmap Beatmap, LegacySkin Skin, Storyboard Storyboard);
+
         [Test]
-        public void TestUnsupportedStoryboardEvents()
+        public void TestStoryboardEvents()
         {
             const string name = "Resources/storyboard_only_video.osu";
 
             var decoded = DecodeFromLegacy(beatmaps_resource_store.GetStream(name), beatmaps_resource_store, name);
-            Assert.That(decoded.beatmap.UnhandledEventLines.Count, Is.EqualTo(1));
-            Assert.That(decoded.beatmap.UnhandledEventLines.Single(), Is.EqualTo("Video,0,\"video.avi\""));
 
             var memoryStream = EncodeToLegacy(decoded);
 
@@ -63,8 +63,8 @@ public void TestEncodeDecodeStability(string name)
             var decoded = DecodeFromLegacy(beatmaps_resource_store.GetStream(name), beatmaps_resource_store, name);
             var decodedAfterEncode = DecodeFromLegacy(EncodeToLegacy(decoded), beatmaps_resource_store, name);
 
-            Sort(decoded.beatmap);
-            Sort(decodedAfterEncode.beatmap);
+            Sort(decoded.Beatmap);
+            Sort(decodedAfterEncode.Beatmap);
 
             CompareBeatmaps(decoded, decodedAfterEncode);
         }
@@ -76,10 +76,10 @@ public void TestEncodeDecodeStabilityDoubleConvert(string name)
             var decodedAfterEncode = DecodeFromLegacy(EncodeToLegacy(decoded), beatmaps_resource_store, name);
 
             // run an extra convert. this is expected to be stable.
-            decodedAfterEncode.beatmap = convert(decodedAfterEncode.beatmap);
+            decodedAfterEncode = decodedAfterEncode with { Beatmap = convert(decodedAfterEncode.Beatmap) };
 
-            Sort(decoded.beatmap);
-            Sort(decodedAfterEncode.beatmap);
+            Sort(decoded.Beatmap);
+            Sort(decodedAfterEncode.Beatmap);
 
             CompareBeatmaps(decoded, decodedAfterEncode);
         }
@@ -91,7 +91,7 @@ public void TestEncodeDecodeStabilityWithNonLegacyControlPoints(string name)
 
             // we are testing that the transfer of relevant data to hitobjects (from legacy control points) sticks through encode/decode.
             // before the encode step, the legacy information is removed here.
-            decoded.beatmap.ControlPointInfo = removeLegacyControlPointTypes(decoded.beatmap.ControlPointInfo);
+            decoded.Beatmap.ControlPointInfo = removeLegacyControlPointTypes(decoded.Beatmap.ControlPointInfo);
 
             var decodedAfterEncode = DecodeFromLegacy(EncodeToLegacy(decoded), beatmaps_resource_store, name);
 
@@ -120,17 +120,21 @@ static ControlPointInfo removeLegacyControlPointTypes(ControlPointInfo controlPo
             }
         }
 
-        public static void CompareBeatmaps((IBeatmap beatmap, TestLegacySkin skin) expected, (IBeatmap beatmap, TestLegacySkin skin) actual)
+        public static void CompareBeatmaps(BeatmapComponents expected, BeatmapComponents actual)
         {
             // Check all control points that are still considered to be at a global level.
-            Assert.That(actual.beatmap.ControlPointInfo.TimingPoints.Serialize(), Is.EqualTo(expected.beatmap.ControlPointInfo.TimingPoints.Serialize()));
-            Assert.That(actual.beatmap.ControlPointInfo.EffectPoints.Serialize(), Is.EqualTo(expected.beatmap.ControlPointInfo.EffectPoints.Serialize()));
+            Assert.That(actual.Beatmap.ControlPointInfo.TimingPoints.Serialize(), Is.EqualTo(expected.Beatmap.ControlPointInfo.TimingPoints.Serialize()));
+            Assert.That(actual.Beatmap.ControlPointInfo.EffectPoints.Serialize(), Is.EqualTo(expected.Beatmap.ControlPointInfo.EffectPoints.Serialize()));
 
             // Check all hitobjects.
-            Assert.That(actual.beatmap.HitObjects.Serialize(), Is.EqualTo(expected.beatmap.HitObjects.Serialize()));
+            Assert.That(actual.Beatmap.HitObjects.Serialize(), Is.EqualTo(expected.Beatmap.HitObjects.Serialize()));
 
             // Check skin.
-            ClassicAssert.True(areComboColoursEqual(expected.skin.Configuration, actual.skin.Configuration));
+            ClassicAssert.True(areComboColoursEqual(expected.Skin.Configuration, actual.Skin.Configuration));
+
+            // Do a rough pass on storyboard layers.
+            foreach (string layer in actual.Storyboard.Layers.Concat(expected.Storyboard.Layers).Select(l => l.Name).Distinct())
+                Assert.That(actual.Storyboard.GetLayer(layer).Elements.Count, Is.EqualTo(expected.Storyboard.GetLayer(layer).Elements.Count));
         }
 
         [Test]
@@ -153,9 +157,9 @@ public void TestEncodeBSplineCurveType()
                 }
             };
 
-            var encoded = EncodeToLegacy((beatmap, new TestLegacySkin(beatmaps_resource_store, string.Empty)));
+            var encoded = EncodeToLegacy(new BeatmapComponents(beatmap, new TestLegacySkin(beatmaps_resource_store, string.Empty), new Storyboard()));
             var decodedAfterEncode = DecodeFromLegacy(encoded, beatmaps_resource_store, string.Empty);
-            var decodedSlider = (Slider)decodedAfterEncode.beatmap.HitObjects[0];
+            var decodedSlider = (Slider)decodedAfterEncode.Beatmap.HitObjects[0];
             Assert.That(decodedSlider.Path.ControlPoints.Count, Is.EqualTo(4));
             Assert.That(decodedSlider.Path.ControlPoints[0].Type, Is.EqualTo(PathType.BSpline(3)));
             Assert.That(decodedSlider.Path.ControlPoints[2].Type, Is.EqualTo(PathType.BSpline(3)));
@@ -183,9 +187,9 @@ public void TestEncodeMultiSegmentSliderWithFloatingPointError()
                 }
             };
 
-            var encoded = EncodeToLegacy((beatmap, new TestLegacySkin(beatmaps_resource_store, string.Empty)));
+            var encoded = EncodeToLegacy(new BeatmapComponents(beatmap, new TestLegacySkin(beatmaps_resource_store, string.Empty), new Storyboard()));
             var decodedAfterEncode = DecodeFromLegacy(encoded, beatmaps_resource_store, string.Empty);
-            var decodedSlider = (Slider)decodedAfterEncode.beatmap.HitObjects[0];
+            var decodedSlider = (Slider)decodedAfterEncode.Beatmap.HitObjects[0];
             Assert.That(decodedSlider.Path.ControlPoints.Count, Is.EqualTo(5));
         }
 
@@ -211,9 +215,9 @@ public void TestOnlyEightComboColoursEncoded()
                 }
             };
 
-            var encoded = EncodeToLegacy((new Beatmap(), beatmapSkin));
+            var encoded = EncodeToLegacy(new BeatmapComponents(new Beatmap(), beatmapSkin, new Storyboard()));
             var decodedAfterEncode = DecodeFromLegacy(encoded, beatmaps_resource_store, string.Empty);
-            Assert.That(decodedAfterEncode.skin.Configuration.CustomComboColours, Has.Count.EqualTo(8));
+            Assert.That(decodedAfterEncode.Skin.Configuration.CustomComboColours, Has.Count.EqualTo(8));
         }
 
         [Test]
@@ -234,9 +238,9 @@ public void TestEncodeStabilityOfSliderWithFractionalCoordinates()
                 HitObjects = { originalSlider }
             };
 
-            var encoded = EncodeToLegacy((beatmap, new TestLegacySkin(beatmaps_resource_store, string.Empty)));
+            var encoded = EncodeToLegacy(new BeatmapComponents(beatmap, new TestLegacySkin(beatmaps_resource_store, string.Empty), new Storyboard()));
             var decodedAfterEncode = DecodeFromLegacy(encoded, beatmaps_resource_store, string.Empty, version: LegacyBeatmapEncoder.FIRST_LAZER_VERSION);
-            var decodedSlider = (Slider)decodedAfterEncode.beatmap.HitObjects[0];
+            var decodedSlider = (Slider)decodedAfterEncode.Beatmap.HitObjects[0];
             Assert.That(decodedSlider.Path.ControlPoints.Select(p => p.Position),
                 Is.EquivalentTo(originalSlider.Path.ControlPoints.Select(p => p.Position)));
         }
@@ -254,17 +258,17 @@ public void TestEncodeCustomSampleBanks()
                 }
             };
 
-            var encoded = EncodeToLegacy((beatmap, new TestLegacySkin(beatmaps_resource_store, string.Empty)));
+            var encoded = EncodeToLegacy(new BeatmapComponents(beatmap, new TestLegacySkin(beatmaps_resource_store, string.Empty), new Storyboard()));
             var decodedAfterEncode = DecodeFromLegacy(encoded, beatmaps_resource_store, string.Empty);
 
-            Assert.That(decodedAfterEncode.beatmap.HitObjects[0].Samples[0].Suffix, Is.Null);
-            Assert.That(decodedAfterEncode.beatmap.HitObjects[0].Samples[0].UseBeatmapSamples, Is.False);
+            Assert.That(decodedAfterEncode.Beatmap.HitObjects[0].Samples[0].Suffix, Is.Null);
+            Assert.That(decodedAfterEncode.Beatmap.HitObjects[0].Samples[0].UseBeatmapSamples, Is.False);
 
-            Assert.That(decodedAfterEncode.beatmap.HitObjects[1].Samples[0].Suffix, Is.Null);
-            Assert.That(decodedAfterEncode.beatmap.HitObjects[1].Samples[0].UseBeatmapSamples, Is.True);
+            Assert.That(decodedAfterEncode.Beatmap.HitObjects[1].Samples[0].Suffix, Is.Null);
+            Assert.That(decodedAfterEncode.Beatmap.HitObjects[1].Samples[0].UseBeatmapSamples, Is.True);
 
-            Assert.That(decodedAfterEncode.beatmap.HitObjects[2].Samples[0].Suffix, Is.EqualTo("3"));
-            Assert.That(decodedAfterEncode.beatmap.HitObjects[2].Samples[0].UseBeatmapSamples, Is.True);
+            Assert.That(decodedAfterEncode.Beatmap.HitObjects[2].Samples[0].Suffix, Is.EqualTo("3"));
+            Assert.That(decodedAfterEncode.Beatmap.HitObjects[2].Samples[0].UseBeatmapSamples, Is.True);
         }
 
         private static bool areComboColoursEqual(IHasComboColours a, IHasComboColours b)
@@ -289,15 +293,17 @@ public static void Sort(IBeatmap beatmap)
             }
         }
 
-        public static (IBeatmap beatmap, TestLegacySkin skin) DecodeFromLegacy(Stream stream, IResourceStore<byte[]> beatmapsResourceStore, string name, int version = LegacyDecoder<Beatmap>.LATEST_VERSION)
+        public static BeatmapComponents DecodeFromLegacy(Stream stream, IResourceStore<byte[]> beatmapsResourceStore, string name, int version = LegacyDecoder<Beatmap>.LATEST_VERSION)
         {
             using (var reader = new LineBufferedReader(stream))
             {
                 var beatmap = new LegacyBeatmapDecoder(version) { ApplyOffsets = false }.Decode(reader);
                 var beatmapSkin = new TestLegacySkin(beatmapsResourceStore, name);
                 stream.Seek(0, SeekOrigin.Begin);
                 beatmapSkin.Configuration = new LegacySkinDecoder().Decode(reader);
-                return (convert(beatmap), beatmapSkin);
+                stream.Seek(0, SeekOrigin.Begin);
+                var storyboard = new LegacyStoryboardDecoder().Decode(reader);
+                return new BeatmapComponents(convert(beatmap), beatmapSkin, storyboard);
             }
         }
 
@@ -309,13 +315,13 @@ public TestLegacySkin(IResourceStore<byte[]> fallbackStore, string fileName)
             }
         }
 
-        public static MemoryStream EncodeToLegacy((IBeatmap beatmap, ISkin skin) fullBeatmap)
+        public static MemoryStream EncodeToLegacy(BeatmapComponents fullBeatmap)
         {
-            var (beatmap, beatmapSkin) = fullBeatmap;
+            var (beatmap, beatmapSkin, storyboard) = fullBeatmap;
             var stream = new MemoryStream();
 
             using (var writer = new StreamWriter(stream, Encoding.UTF8, 1024, true))
-                new LegacyBeatmapEncoder(beatmap, beatmapSkin).Encode(writer);
+                new LegacyBeatmapEncoder(beatmap, beatmapSkin, storyboard).Encode(writer);
 
             stream.Position = 0;