Merge pull request #16861 from bdach/copy-existing-difficulty

Add option to create copy of existing difficulty

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

@@ -6,15 +6,23 @@ using System.IO;
 using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
+using osu.Framework.Graphics;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Database;
 using osu.Game.Rulesets;
+using osu.Game.Rulesets.Catch;
 using osu.Game.Rulesets.Osu;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Setup;
 using osu.Game.Storyboards;
 using osu.Game.Tests.Resources;
+using osuTK;
 using SharpCompress.Archives;
 using SharpCompress.Archives.Zip;
 
@@ -92,12 +100,27 @@ namespace osu.Game.Tests.Visual.Editing
         }
 
         [Test]
-        public void TestCreateNewDifficulty()
+        public void TestCreateNewDifficulty([Values] bool sameRuleset)
         {
             string firstDifficultyName = Guid.NewGuid().ToString();
             string secondDifficultyName = Guid.NewGuid().ToString();
 
             AddStep("set unique difficulty name", () => EditorBeatmap.BeatmapInfo.DifficultyName = firstDifficultyName);
+            AddStep("add timing point", () => EditorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = 1000 }));
+            AddStep("add hitobjects", () => EditorBeatmap.AddRange(new[]
+            {
+                new HitCircle
+                {
+                    Position = new Vector2(0),
+                    StartTime = 0
+                },
+                new HitCircle
+                {
+                    Position = OsuPlayfield.BASE_SIZE,
+                    StartTime = 1000
+                }
+            }));
+
             AddStep("save beatmap", () => Editor.Save());
             AddAssert("new beatmap persisted", () =>
             {
@@ -111,13 +134,27 @@ namespace osu.Game.Tests.Visual.Editing
             });
             AddAssert("can save again", () => Editor.Save());
 
-            AddStep("create new difficulty", () => Editor.CreateNewDifficulty(new OsuRuleset().RulesetInfo));
+            AddStep("create new difficulty", () => Editor.CreateNewDifficulty(sameRuleset ? new OsuRuleset().RulesetInfo : new CatchRuleset().RulesetInfo));
+
+            if (sameRuleset)
+            {
+                AddUntilStep("wait for dialog", () => DialogOverlay.CurrentDialog is CreateNewDifficultyDialog);
+                AddStep("confirm creation with no objects", () => DialogOverlay.CurrentDialog.PerformOkAction());
+            }
+
             AddUntilStep("wait for created", () =>
             {
                 string difficultyName = Editor.ChildrenOfType<EditorBeatmap>().SingleOrDefault()?.BeatmapInfo.DifficultyName;
                 return difficultyName != null && difficultyName != firstDifficultyName;
             });
 
+            AddAssert("created difficulty has timing point", () =>
+            {
+                var timingPoint = EditorBeatmap.ControlPointInfo.TimingPoints.Single();
+                return timingPoint.Time == 0 && timingPoint.BeatLength == 1000;
+            });
+            AddAssert("created difficulty has no objects", () => EditorBeatmap.HitObjects.Count == 0);
+
             AddStep("set unique difficulty name", () => EditorBeatmap.BeatmapInfo.DifficultyName = secondDifficultyName);
             AddStep("save beatmap", () => Editor.Save());
             AddAssert("new beatmap persisted", () =>
@@ -132,6 +169,105 @@ namespace osu.Game.Tests.Visual.Editing
             });
         }
 
+        [Test]
+        public void TestCopyDifficulty()
+        {
+            string originalDifficultyName = Guid.NewGuid().ToString();
+            string copyDifficultyName = $"{originalDifficultyName} (copy)";
+
+            AddStep("set unique difficulty name", () => EditorBeatmap.BeatmapInfo.DifficultyName = originalDifficultyName);
+            AddStep("add timing point", () => EditorBeatmap.ControlPointInfo.Add(0, new TimingControlPoint { BeatLength = 1000 }));
+            AddStep("add hitobjects", () => EditorBeatmap.AddRange(new[]
+            {
+                new HitCircle
+                {
+                    Position = new Vector2(0),
+                    StartTime = 0
+                },
+                new HitCircle
+                {
+                    Position = OsuPlayfield.BASE_SIZE,
+                    StartTime = 1000
+                }
+            }));
+            AddStep("set approach rate", () => EditorBeatmap.Difficulty.ApproachRate = 4);
+            AddStep("set combo colours", () =>
+            {
+                var beatmapSkin = EditorBeatmap.BeatmapSkin.AsNonNull();
+                beatmapSkin.ComboColours.Clear();
+                beatmapSkin.ComboColours.AddRange(new[]
+                {
+                    new Colour4(255, 0, 0, 255),
+                    new Colour4(0, 0, 255, 255)
+                });
+            });
+            AddStep("set status & online ID", () =>
+            {
+                EditorBeatmap.BeatmapInfo.OnlineID = 123456;
+                EditorBeatmap.BeatmapInfo.Status = BeatmapOnlineStatus.WIP;
+            });
+
+            AddStep("save beatmap", () => Editor.Save());
+            AddAssert("new beatmap persisted", () =>
+            {
+                var beatmap = beatmapManager.QueryBeatmap(b => b.DifficultyName == originalDifficultyName);
+                var set = beatmapManager.QueryBeatmapSet(s => s.ID == EditorBeatmap.BeatmapInfo.BeatmapSet.ID);
+
+                return beatmap != null
+                       && beatmap.DifficultyName == originalDifficultyName
+                       && set != null
+                       && set.PerformRead(s => s.Beatmaps.Single().ID == beatmap.ID);
+            });
+            AddAssert("can save again", () => Editor.Save());
+
+            AddStep("create new difficulty", () => Editor.CreateNewDifficulty(new OsuRuleset().RulesetInfo));
+
+            AddUntilStep("wait for dialog", () => DialogOverlay.CurrentDialog is CreateNewDifficultyDialog);
+            AddStep("confirm creation as a copy", () => DialogOverlay.CurrentDialog.Buttons.ElementAt(1).TriggerClick());
+
+            AddUntilStep("wait for created", () =>
+            {
+                string difficultyName = Editor.ChildrenOfType<EditorBeatmap>().SingleOrDefault()?.BeatmapInfo.DifficultyName;
+                return difficultyName != null && difficultyName != originalDifficultyName;
+            });
+
+            AddAssert("created difficulty has copy suffix in name", () => EditorBeatmap.BeatmapInfo.DifficultyName == copyDifficultyName);
+            AddAssert("created difficulty has timing point", () =>
+            {
+                var timingPoint = EditorBeatmap.ControlPointInfo.TimingPoints.Single();
+                return timingPoint.Time == 0 && timingPoint.BeatLength == 1000;
+            });
+            AddAssert("created difficulty has objects", () => EditorBeatmap.HitObjects.Count == 2);
+            AddAssert("approach rate correctly copied", () => EditorBeatmap.Difficulty.ApproachRate == 4);
+            AddAssert("combo colours correctly copied", () => EditorBeatmap.BeatmapSkin.AsNonNull().ComboColours.Count == 2);
+
+            AddAssert("status not copied", () => EditorBeatmap.BeatmapInfo.Status == BeatmapOnlineStatus.None);
+            AddAssert("online ID not copied", () => EditorBeatmap.BeatmapInfo.OnlineID == -1);
+
+            AddStep("save beatmap", () => Editor.Save());
+
+            BeatmapInfo refetchedBeatmap = null;
+            Live<BeatmapSetInfo> refetchedBeatmapSet = null;
+
+            AddStep("refetch from database", () =>
+            {
+                refetchedBeatmap = beatmapManager.QueryBeatmap(b => b.DifficultyName == copyDifficultyName);
+                refetchedBeatmapSet = beatmapManager.QueryBeatmapSet(s => s.ID == EditorBeatmap.BeatmapInfo.BeatmapSet.ID);
+            });
+
+            AddAssert("new beatmap persisted", () =>
+            {
+                return refetchedBeatmap != null
+                       && refetchedBeatmap.DifficultyName == copyDifficultyName
+                       && refetchedBeatmapSet != null
+                       && refetchedBeatmapSet.PerformRead(s =>
+                           s.Beatmaps.Count == 2
+                           && s.Beatmaps.Any(b => b.DifficultyName == originalDifficultyName)
+                           && s.Beatmaps.Any(b => b.DifficultyName == copyDifficultyName));
+            });
+            AddAssert("old beatmap file not deleted", () => refetchedBeatmapSet.AsNonNull().PerformRead(s => s.Files.Count == 2));
+        }
+
         [Test]
         public void TestCreateNewBeatmapFailsWithBlankNamedDifficulties()
         {
@@ -154,7 +290,7 @@ namespace osu.Game.Tests.Visual.Editing
         }
 
         [Test]
-        public void TestCreateNewBeatmapFailsWithSameNamedDifficulties()
+        public void TestCreateNewBeatmapFailsWithSameNamedDifficulties([Values] bool sameRuleset)
         {
             Guid setId = Guid.Empty;
             const string duplicate_difficulty_name = "duplicate";
@@ -168,7 +304,14 @@ namespace osu.Game.Tests.Visual.Editing
                 return set != null && set.PerformRead(s => s.Beatmaps.Count == 1 && s.Files.Count == 1);
             });
 
-            AddStep("create new difficulty", () => Editor.CreateNewDifficulty(new OsuRuleset().RulesetInfo));
+            AddStep("create new difficulty", () => Editor.CreateNewDifficulty(sameRuleset ? new OsuRuleset().RulesetInfo : new CatchRuleset().RulesetInfo));
+
+            if (sameRuleset)
+            {
+                AddUntilStep("wait for dialog", () => DialogOverlay.CurrentDialog is CreateNewDifficultyDialog);
+                AddStep("confirm creation with no objects", () => DialogOverlay.CurrentDialog.PerformOkAction());
+            }
+
             AddUntilStep("wait for created", () =>
             {
                 string difficultyName = Editor.ChildrenOfType<EditorBeatmap>().SingleOrDefault()?.BeatmapInfo.DifficultyName;

osu.Game/Beatmaps/BeatmapManager.cs

@@ -108,39 +108,73 @@ namespace osu.Game.Beatmaps
         }
 
         /// <summary>
-        /// Add a new difficulty to the beatmap set represented by the provided <see cref="BeatmapSetInfo"/>.
+        /// Add a new difficulty to the provided <paramref name="targetBeatmapSet"/> based on the provided <paramref name="referenceWorkingBeatmap"/>.
         /// The new difficulty will be backed by a <see cref="BeatmapInfo"/> model
         /// and represented by the returned <see cref="WorkingBeatmap"/>.
         /// </summary>
-        public virtual WorkingBeatmap CreateNewBlankDifficulty(BeatmapSetInfo beatmapSetInfo, RulesetInfo rulesetInfo)
+        /// <remarks>
+        /// Contrary to <see cref="CopyExistingDifficulty"/>, this method does not preserve hitobjects and beatmap-level settings from <paramref name="referenceWorkingBeatmap"/>.
+        /// The created beatmap will have zero hitobjects and will have default settings (including difficulty settings), but will preserve metadata and existing timing points.
+        /// </remarks>
+        /// <param name="targetBeatmapSet">The <see cref="BeatmapSetInfo"/> to add the new difficulty to.</param>
+        /// <param name="referenceWorkingBeatmap">The <see cref="WorkingBeatmap"/> to use as a baseline reference when creating the new difficulty.</param>
+        /// <param name="rulesetInfo">The ruleset with which the new difficulty should be created.</param>
+        public virtual WorkingBeatmap CreateNewDifficulty(BeatmapSetInfo targetBeatmapSet, WorkingBeatmap referenceWorkingBeatmap, RulesetInfo rulesetInfo)
         {
-            // fetch one of the existing difficulties to copy timing points and metadata from,
-            // so that the user doesn't have to fill all of that out again.
-            // this silently assumes that all difficulties have the same timing points and metadata,
-            // but cases where this isn't true seem rather rare / pathological.
-            var referenceBeatmap = GetWorkingBeatmap(beatmapSetInfo.Beatmaps.First());
+            var playableBeatmap = referenceWorkingBeatmap.GetPlayableBeatmap(rulesetInfo);
 
-            var newBeatmapInfo = new BeatmapInfo(rulesetInfo, new BeatmapDifficulty(), referenceBeatmap.Metadata.DeepClone());
+            var newBeatmapInfo = new BeatmapInfo(rulesetInfo, new BeatmapDifficulty(), playableBeatmap.Metadata.DeepClone());
+            var newBeatmap = new Beatmap { BeatmapInfo = newBeatmapInfo };
+            foreach (var timingPoint in playableBeatmap.ControlPointInfo.TimingPoints)
+                newBeatmap.ControlPointInfo.Add(timingPoint.Time, timingPoint.DeepClone());
 
+            return addDifficultyToSet(targetBeatmapSet, newBeatmap, referenceWorkingBeatmap.Skin);
+        }
+
+        /// <summary>
+        /// Add a copy of the provided <paramref name="referenceWorkingBeatmap"/> to the provided <paramref name="targetBeatmapSet"/>.
+        /// The new difficulty will be backed by a <see cref="BeatmapInfo"/> model
+        /// and represented by the returned <see cref="WorkingBeatmap"/>.
+        /// </summary>
+        /// <remarks>
+        /// Contrary to <see cref="CreateNewDifficulty"/>, this method creates a nearly-exact copy of <paramref name="referenceWorkingBeatmap"/>
+        /// (with the exception of a few key properties that cannot be copied under any circumstance, like difficulty name, beatmap hash, or online status).
+        /// </remarks>
+        /// <param name="targetBeatmapSet">The <see cref="BeatmapSetInfo"/> to add the copy to.</param>
+        /// <param name="referenceWorkingBeatmap">The <see cref="WorkingBeatmap"/> to be copied.</param>
+        public virtual WorkingBeatmap CopyExistingDifficulty(BeatmapSetInfo targetBeatmapSet, WorkingBeatmap referenceWorkingBeatmap)
+        {
+            var newBeatmap = referenceWorkingBeatmap.GetPlayableBeatmap(referenceWorkingBeatmap.BeatmapInfo.Ruleset).Clone();
+            BeatmapInfo newBeatmapInfo;
+
+            newBeatmap.BeatmapInfo = newBeatmapInfo = referenceWorkingBeatmap.BeatmapInfo.Clone();
+            // assign a new ID to the clone.
+            newBeatmapInfo.ID = Guid.NewGuid();
+            // add "(copy)" suffix to difficulty name to avoid clashes on save.
+            newBeatmapInfo.DifficultyName += " (copy)";
+            // clear the hash, as that's what is used to match .osu files with their corresponding realm beatmaps.
+            newBeatmapInfo.Hash = string.Empty;
+            // clear online properties.
+            newBeatmapInfo.OnlineID = -1;
+            newBeatmapInfo.Status = BeatmapOnlineStatus.None;
+
+            return addDifficultyToSet(targetBeatmapSet, newBeatmap, referenceWorkingBeatmap.Skin);
+        }
+
+        private WorkingBeatmap addDifficultyToSet(BeatmapSetInfo targetBeatmapSet, IBeatmap newBeatmap, ISkin beatmapSkin)
+        {
             // populate circular beatmap set info <-> beatmap info references manually.
             // several places like `BeatmapModelManager.Save()` or `GetWorkingBeatmap()`
             // rely on them being freely traversable in both directions for correct operation.
-            beatmapSetInfo.Beatmaps.Add(newBeatmapInfo);
-            newBeatmapInfo.BeatmapSet = beatmapSetInfo;
+            targetBeatmapSet.Beatmaps.Add(newBeatmap.BeatmapInfo);
+            newBeatmap.BeatmapInfo.BeatmapSet = targetBeatmapSet;
 
-            var newBeatmap = new Beatmap { BeatmapInfo = newBeatmapInfo };
-            foreach (var timingPoint in referenceBeatmap.Beatmap.ControlPointInfo.TimingPoints)
-                newBeatmap.ControlPointInfo.Add(timingPoint.Time, timingPoint.DeepClone());
+            beatmapModelManager.Save(newBeatmap.BeatmapInfo, newBeatmap, beatmapSkin);
 
-            beatmapModelManager.Save(newBeatmapInfo, newBeatmap);
-
-            workingBeatmapCache.Invalidate(beatmapSetInfo);
+            workingBeatmapCache.Invalidate(targetBeatmapSet);
             return GetWorkingBeatmap(newBeatmap.BeatmapInfo);
         }
 
-        // TODO: add back support for making a copy of another difficulty
-        // (likely via a separate `CopyDifficulty()` method).
-
         /// <summary>
         /// Delete a beatmap difficulty.
         /// </summary>

osu.Game/Screens/Edit/CreateNewDifficultyDialog.cs

@@ -0,0 +1,45 @@
+// 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.Graphics.Sprites;
+using osu.Game.Overlays.Dialog;
+
+namespace osu.Game.Screens.Edit
+{
+    public class CreateNewDifficultyDialog : PopupDialog
+    {
+        /// <summary>
+        /// Delegate used to create new difficulties.
+        /// A value of <see langword="true"/> in the <c>createCopy</c> parameter
+        /// indicates that the new difficulty should be an exact copy of an existing one;
+        /// otherwise, the new difficulty should have its hitobjects and beatmap-level settings cleared.
+        /// </summary>
+        public delegate void CreateNewDifficulty(bool createCopy);
+
+        public CreateNewDifficultyDialog(CreateNewDifficulty createNewDifficulty)
+        {
+            HeaderText = "Would you like to create a blank difficulty?";
+
+            Icon = FontAwesome.Regular.Clone;
+
+            Buttons = new PopupDialogButton[]
+            {
+                new PopupDialogOkButton
+                {
+                    Text = "Yeah, let's start from scratch!",
+                    Action = () => createNewDifficulty.Invoke(false)
+                },
+                new PopupDialogCancelButton
+                {
+                    Text = "No, create an exact copy of this difficulty",
+                    Action = () => createNewDifficulty.Invoke(true)
+                },
+                new PopupDialogCancelButton
+                {
+                    Text = "I changed my mind, I want to keep editing this difficulty",
+                    Action = () => { }
+                }
+            };
+        }
+    }
+}

osu.Game/Screens/Edit/Editor.cs

@@ -358,14 +358,14 @@ namespace osu.Game.Screens.Edit
         /// <summary>
         /// Creates an <see cref="EditorState"/> instance representing the current state of the editor.
         /// </summary>
-        /// <param name="nextBeatmap">
-        /// The next beatmap to be shown, in the case of difficulty switch.
+        /// <param name="nextRuleset">
+        /// The ruleset of the next beatmap to be shown, in the case of difficulty switch.
         /// <see langword="null"/> indicates that the beatmap will not be changing.
         /// </param>
-        public EditorState GetState([CanBeNull] BeatmapInfo nextBeatmap = null) => new EditorState
+        public EditorState GetState([CanBeNull] RulesetInfo nextRuleset = null) => new EditorState
         {
             Time = clock.CurrentTimeAccurate,
-            ClipboardContent = nextBeatmap == null || editorBeatmap.BeatmapInfo.Ruleset.ShortName == nextBeatmap.Ruleset.ShortName ? Clipboard.Content.Value : string.Empty
+            ClipboardContent = nextRuleset == null || editorBeatmap.BeatmapInfo.Ruleset.ShortName == nextRuleset.ShortName ? Clipboard.Content.Value : string.Empty
         };
 
         /// <summary>
@@ -841,7 +841,18 @@ namespace osu.Game.Screens.Edit
         }
 
         protected void CreateNewDifficulty(RulesetInfo rulesetInfo)
-            => loader?.ScheduleSwitchToNewDifficulty(editorBeatmap.BeatmapInfo.BeatmapSet, rulesetInfo, GetState());
+        {
+            if (!rulesetInfo.Equals(editorBeatmap.BeatmapInfo.Ruleset))
+            {
+                switchToNewDifficulty(rulesetInfo, false);
+                return;
+            }
+
+            dialogOverlay.Push(new CreateNewDifficultyDialog(createCopy => switchToNewDifficulty(rulesetInfo, createCopy)));
+        }
+
+        private void switchToNewDifficulty(RulesetInfo rulesetInfo, bool createCopy)
+            => loader?.ScheduleSwitchToNewDifficulty(editorBeatmap.BeatmapInfo, rulesetInfo, createCopy, GetState(rulesetInfo));
 
         private EditorMenuItem createDifficultySwitchMenu()
         {
@@ -866,7 +877,7 @@ namespace osu.Game.Screens.Edit
             return new EditorMenuItem("Change difficulty") { Items = difficultyItems };
         }
 
-        protected void SwitchToDifficulty(BeatmapInfo nextBeatmap) => loader?.ScheduleSwitchToExistingDifficulty(nextBeatmap, GetState(nextBeatmap));
+        protected void SwitchToDifficulty(BeatmapInfo nextBeatmap) => loader?.ScheduleSwitchToExistingDifficulty(nextBeatmap, GetState(nextBeatmap.Ruleset));
 
         private void cancelExit()
         {

osu.Game/Screens/Edit/EditorLoader.cs

@@ -4,6 +4,7 @@
 using System;
 using JetBrains.Annotations;
 using osu.Framework.Allocation;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
@@ -80,12 +81,18 @@ namespace osu.Game.Screens.Edit
             }
         }
 
-        public void ScheduleSwitchToNewDifficulty(BeatmapSetInfo beatmapSetInfo, RulesetInfo rulesetInfo, EditorState editorState)
+        public void ScheduleSwitchToNewDifficulty(BeatmapInfo referenceBeatmapInfo, RulesetInfo rulesetInfo, bool createCopy, EditorState editorState)
             => scheduleDifficultySwitch(() =>
             {
                 try
                 {
-                    return beatmapManager.CreateNewBlankDifficulty(beatmapSetInfo, rulesetInfo);
+                    // fetch a fresh detached reference from database to avoid polluting model instances attached to cached working beatmaps.
+                    var targetBeatmapSet = beatmapManager.QueryBeatmap(b => b.ID == referenceBeatmapInfo.ID).AsNonNull().BeatmapSet.AsNonNull();
+                    var referenceWorkingBeatmap = beatmapManager.GetWorkingBeatmap(referenceBeatmapInfo);
+
+                    return createCopy
+                        ? beatmapManager.CopyExistingDifficulty(targetBeatmapSet, referenceWorkingBeatmap)
+                        : beatmapManager.CreateNewDifficulty(targetBeatmapSet, referenceWorkingBeatmap, rulesetInfo);
                 }
                 catch (Exception ex)
                 {

osu.Game/Tests/Visual/EditorTestScene.cs

@@ -136,7 +136,13 @@ namespace osu.Game.Tests.Visual
                 return new TestWorkingBeatmapCache(this, audioManager, resources, storage, defaultBeatmap, host);
             }
 
-            public override WorkingBeatmap CreateNewBlankDifficulty(BeatmapSetInfo beatmapSetInfo, RulesetInfo rulesetInfo)
+            public override WorkingBeatmap CreateNewDifficulty(BeatmapSetInfo targetBeatmapSet, WorkingBeatmap referenceWorkingBeatmap, RulesetInfo rulesetInfo)
+            {
+                // don't actually care about properly creating a difficulty for this context.
+                return TestBeatmap;
+            }
+
+            public override WorkingBeatmap CopyExistingDifficulty(BeatmapSetInfo targetBeatmapSet, WorkingBeatmap referenceWorkingBeatmap)
             {
                 // don't actually care about properly creating a difficulty for this context.
                 return TestBeatmap;