Merge pull request #30860 from frenzibyte/editor-multiple-background-audio-files

Allow choosing different background/audio files for individual difficulties

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

@@ -4,11 +4,13 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Text;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio.Track;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
+using osu.Framework.Platform;
 using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Game.Beatmaps;
@@ -28,6 +30,7 @@ using osu.Game.Rulesets.Taiko.Objects;
 using osu.Game.Screens.Edit;
 using osu.Game.Screens.Edit.Compose.Components.Timeline;
 using osu.Game.Screens.Edit.Setup;
+using osu.Game.Skinning;
 using osu.Game.Storyboards;
 using osu.Game.Tests.Resources;
 using osuTK;
@@ -99,44 +102,15 @@ namespace osu.Game.Tests.Visual.Editing
             AddStep("enter compose mode", () => InputManager.Key(Key.F1));
             AddUntilStep("wait for timeline load", () => Editor.ChildrenOfType<Timeline>().FirstOrDefault()?.IsLoaded == true);
 
-            AddStep("enter setup mode", () => InputManager.Key(Key.F4));
+            AddStep("enter setup mode", () => Editor.Mode.Value = EditorScreenMode.SongSetup);
             AddAssert("track is virtual", () => Beatmap.Value.Track is TrackVirtual);
-            AddAssert("switch track to real track", () =>
-            {
-                var setup = Editor.ChildrenOfType<SetupScreen>().First();
-
-                string temp = TestResources.GetTestBeatmapForImport();
-
-                string extractedFolder = $"{temp}_extracted";
-                Directory.CreateDirectory(extractedFolder);
-
-                try
-                {
-                    using (var zip = ZipArchive.Open(temp))
-                        zip.WriteToDirectory(extractedFolder);
-
-                    bool success = setup.ChildrenOfType<ResourcesSection>().First().ChangeAudioTrack(new FileInfo(Path.Combine(extractedFolder, "03. Renatus - Soleily 192kbps.mp3")));
-
-                    // ensure audio file is copied to beatmap as "audio.mp3" rather than original filename.
-                    Assert.That(Beatmap.Value.Metadata.AudioFile == "audio.mp3");
-
-                    return success;
-                }
-                finally
-                {
-                    File.Delete(temp);
-                    Directory.Delete(extractedFolder, true);
-                }
-            });
+            AddAssert("switch track to real track", () => setAudio(applyToAllDifficulties: true, expected: "audio.mp3"));
 
             AddAssert("track is not virtual", () => Beatmap.Value.Track is not TrackVirtual);
             AddUntilStep("track length changed", () => Beatmap.Value.Track.Length > 60000);
 
             AddStep("test play", () => Editor.TestGameplay());
 
-            AddUntilStep("wait for dialog", () => DialogOverlay.CurrentDialog != null);
-            AddStep("confirm save", () => InputManager.Key(Key.Number1));
-
             AddUntilStep("wait for return to editor", () => Editor.IsCurrentScreen());
 
             AddAssert("track is still not virtual", () => Beatmap.Value.Track is not TrackVirtual);
@@ -635,5 +609,228 @@ namespace osu.Game.Tests.Visual.Editing
                 return set != null && set.PerformRead(s => s.Beatmaps.Count == 3 && s.Files.Count == 3);
             });
         }
+
+        [Test]
+        public void TestSingleBackgroundFile()
+        {
+            AddStep("enter setup mode", () => Editor.Mode.Value = EditorScreenMode.SongSetup);
+            AddAssert("set background", () => setBackground(applyToAllDifficulties: true, expected: "bg.jpg"));
+
+            createNewDifficulty();
+            createNewDifficulty();
+
+            switchToDifficulty(1);
+
+            AddAssert("set background on second diff only", () => setBackground(applyToAllDifficulties: false, expected: "bg (1).jpg"));
+            AddAssert("file added", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "bg (1).jpg"));
+
+            switchToDifficulty(0);
+
+            AddAssert("set background on first diff only", () => setBackground(applyToAllDifficulties: false, expected: "bg (2).jpg"));
+            AddAssert("file added", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "bg (2).jpg"));
+
+            AddAssert("set background on all diff", () => setBackground(applyToAllDifficulties: true, expected: "bg.jpg"));
+            AddAssert("all diff uses one background", () => Beatmap.Value.BeatmapSetInfo.Beatmaps.All(b => b.Metadata.BackgroundFile == "bg.jpg"));
+            AddAssert("file added", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "bg.jpg"));
+            AddAssert("other files removed", () => !Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "bg (1).jpg" || f.Filename == "bg (2).jpg"));
+        }
+
+        [Test]
+        public void TestBackgroundFileChangesPreserveOnEncode()
+        {
+            AddStep("enter setup mode", () => Editor.Mode.Value = EditorScreenMode.SongSetup);
+            AddAssert("set background", () => setBackground(applyToAllDifficulties: true, expected: "bg.jpg"));
+
+            createNewDifficulty();
+            createNewDifficulty();
+
+            switchToDifficulty(0);
+
+            AddAssert("set different background on all diff", () => setBackgroundDifferentExtension(applyToAllDifficulties: true, expected: "bg.jpeg"));
+            AddAssert("all diff uses one background", () => Beatmap.Value.BeatmapSetInfo.Beatmaps.All(b => b.Metadata.BackgroundFile == "bg.jpeg"));
+            AddAssert("all diff encode same background", () =>
+            {
+                return Beatmap.Value.BeatmapSetInfo.Beatmaps.All(b =>
+                {
+                    var files = new RealmFileStore(Realm, Dependencies.Get<GameHost>().Storage);
+                    using var store = new RealmBackedResourceStore<BeatmapSetInfo>(b.BeatmapSet!.ToLive(Realm), files.Store, Realm);
+                    string[] osu = Encoding.UTF8.GetString(store.Get(b.File!.Filename)).Split(Environment.NewLine);
+                    Assert.That(osu, Does.Contain("0,0,\"bg.jpeg\",0,0"));
+                    return true;
+                });
+            });
+        }
+
+        [Test]
+        public void TestSingleAudioFile()
+        {
+            AddStep("enter setup mode", () => Editor.Mode.Value = EditorScreenMode.SongSetup);
+            AddAssert("set audio", () => setAudio(applyToAllDifficulties: true, expected: "audio.mp3"));
+
+            createNewDifficulty();
+            createNewDifficulty();
+
+            switchToDifficulty(1);
+
+            AddAssert("set audio on second diff only", () => setAudio(applyToAllDifficulties: false, expected: "audio (1).mp3"));
+            AddAssert("file added", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "audio (1).mp3"));
+
+            switchToDifficulty(0);
+
+            AddAssert("set audio on first diff only", () => setAudio(applyToAllDifficulties: false, expected: "audio (2).mp3"));
+            AddAssert("file added", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "audio (2).mp3"));
+
+            AddAssert("set audio on all diff", () => setAudio(applyToAllDifficulties: true, expected: "audio.mp3"));
+            AddAssert("all diff uses one audio", () => Beatmap.Value.BeatmapSetInfo.Beatmaps.All(b => b.Metadata.AudioFile == "audio.mp3"));
+            AddAssert("file added", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "audio.mp3"));
+            AddAssert("other files removed", () => !Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "audio (1).mp3" || f.Filename == "audio (2).mp3"));
+        }
+
+        [Test]
+        public void TestMultipleBackgroundFiles()
+        {
+            AddStep("enter setup mode", () => Editor.Mode.Value = EditorScreenMode.SongSetup);
+            AddAssert("set background", () => setBackground(applyToAllDifficulties: false, expected: "bg.jpg"));
+
+            createNewDifficulty();
+
+            AddAssert("new difficulty uses same background", () => Beatmap.Value.Metadata.BackgroundFile == "bg.jpg");
+            AddAssert("set background", () => setBackground(applyToAllDifficulties: false, expected: "bg (1).jpg"));
+            AddAssert("new difficulty uses new background", () => Beatmap.Value.Metadata.BackgroundFile == "bg (1).jpg");
+
+            switchToDifficulty(0);
+
+            AddAssert("old difficulty uses old background", () => Beatmap.Value.Metadata.BackgroundFile == "bg.jpg");
+            AddAssert("old background not removed", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "bg.jpg"));
+            AddStep("set background", () => setBackground(applyToAllDifficulties: false, expected: "bg.jpg"));
+            AddAssert("other background not removed", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "bg (1).jpg"));
+        }
+
+        [Test]
+        public void TestMultipleAudioFiles()
+        {
+            AddStep("enter setup mode", () => Editor.Mode.Value = EditorScreenMode.SongSetup);
+            AddAssert("set audio", () => setAudio(applyToAllDifficulties: false, expected: "audio.mp3"));
+
+            createNewDifficulty();
+
+            AddAssert("new difficulty uses same audio", () => Beatmap.Value.Metadata.AudioFile == "audio.mp3");
+            AddStep("enter setup mode", () => Editor.Mode.Value = EditorScreenMode.SongSetup);
+            AddUntilStep("wait for load", () => Editor.ChildrenOfType<SetupScreen>().Any());
+            AddAssert("set audio", () => setAudio(applyToAllDifficulties: false, expected: "audio (1).mp3"));
+            AddAssert("new difficulty uses new audio", () => Beatmap.Value.Metadata.AudioFile == "audio (1).mp3");
+
+            switchToDifficulty(0);
+
+            AddAssert("old difficulty uses old audio", () => Beatmap.Value.Metadata.AudioFile == "audio.mp3");
+            AddAssert("old audio not removed", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "audio.mp3"));
+            AddStep("set audio", () => setAudio(applyToAllDifficulties: false, expected: "audio.mp3"));
+            AddAssert("other audio not removed", () => Beatmap.Value.BeatmapSetInfo.Files.Any(f => f.Filename == "audio (1).mp3"));
+        }
+
+        private void createNewDifficulty()
+        {
+            string? currentDifficulty = null;
+
+            AddStep("save", () => Editor.Save());
+            AddStep("create new difficulty", () =>
+            {
+                currentDifficulty = EditorBeatmap.BeatmapInfo.DifficultyName;
+                Editor.CreateNewDifficulty(new OsuRuleset().RulesetInfo);
+            });
+
+            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 != currentDifficulty;
+            });
+
+            AddUntilStep("wait for editor load", () => Editor.IsLoaded);
+            AddStep("enter setup mode", () => Editor.Mode.Value = EditorScreenMode.SongSetup);
+            AddUntilStep("wait for load", () => Editor.ChildrenOfType<SetupScreen>().Any());
+        }
+
+        private void switchToDifficulty(int index)
+        {
+            AddStep("save", () => Editor.Save());
+            AddStep($"switch to difficulty #{index + 1}", () =>
+                Editor.SwitchToDifficulty(Beatmap.Value.BeatmapSetInfo.Beatmaps.ElementAt(index)));
+
+            AddUntilStep("wait for editor load", () => Editor.IsLoaded);
+            AddStep("enter setup mode", () => Editor.Mode.Value = EditorScreenMode.SongSetup);
+            AddUntilStep("wait for load", () => Editor.ChildrenOfType<SetupScreen>().Any());
+        }
+
+        private bool setBackground(bool applyToAllDifficulties, string expected)
+        {
+            var setup = Editor.ChildrenOfType<SetupScreen>().First();
+
+            return setFile(TestResources.GetQuickTestBeatmapForImport(), extractedFolder =>
+            {
+                bool success = setup.ChildrenOfType<ResourcesSection>().First().ChangeBackgroundImage(
+                    new FileInfo(Path.Combine(extractedFolder, @"machinetop_background.jpg")),
+                    applyToAllDifficulties);
+
+                Assert.That(Beatmap.Value.Metadata.BackgroundFile, Is.EqualTo(expected));
+                return success;
+            });
+        }
+
+        private bool setBackgroundDifferentExtension(bool applyToAllDifficulties, string expected)
+        {
+            var setup = Editor.ChildrenOfType<SetupScreen>().First();
+
+            return setFile(TestResources.GetQuickTestBeatmapForImport(), extractedFolder =>
+            {
+                File.Move(
+                    Path.Combine(extractedFolder, @"machinetop_background.jpg"),
+                    Path.Combine(extractedFolder, @"machinetop_background.jpeg"));
+
+                bool success = setup.ChildrenOfType<ResourcesSection>().First().ChangeBackgroundImage(
+                    new FileInfo(Path.Combine(extractedFolder, @"machinetop_background.jpeg")),
+                    applyToAllDifficulties);
+
+                Assert.That(Beatmap.Value.Metadata.BackgroundFile, Is.EqualTo(expected));
+                return success;
+            });
+        }
+
+        private bool setAudio(bool applyToAllDifficulties, string expected)
+        {
+            var setup = Editor.ChildrenOfType<SetupScreen>().First();
+
+            return setFile(TestResources.GetTestBeatmapForImport(), extractedFolder =>
+            {
+                bool success = setup.ChildrenOfType<ResourcesSection>().First().ChangeAudioTrack(
+                    new FileInfo(Path.Combine(extractedFolder, "03. Renatus - Soleily 192kbps.mp3")),
+                    applyToAllDifficulties);
+
+                Assert.That(Beatmap.Value.Metadata.AudioFile, Is.EqualTo(expected));
+                return success;
+            });
+        }
+
+        private bool setFile(string archivePath, Func<string, bool> func)
+        {
+            string temp = archivePath;
+
+            string extractedFolder = $"{temp}_extracted";
+            Directory.CreateDirectory(extractedFolder);
+
+            try
+            {
+                using (var zip = ZipArchive.Open(temp))
+                    zip.WriteToDirectory(extractedFolder);
+
+                return func(extractedFolder);
+            }
+            finally
+            {
+                File.Delete(temp);
+                Directory.Delete(extractedFolder, true);
+            }
+        }
     }
 }

osu.Game.Tests/Visual/UserInterface/TestSceneFormControls.cs

@@ -9,6 +9,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Graphics.Cursor;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Localisation;
+using osu.Game.Screens.Edit.Setup;
 using osuTK;
 
 namespace osu.Game.Tests.Visual.UserInterface
@@ -89,8 +90,13 @@ namespace osu.Game.Tests.Visual.UserInterface
                         },
                         new FormFileSelector
                         {
-                            Caption = "Audio file",
-                            PlaceholderText = "Select an audio file",
+                            Caption = "File selector",
+                            PlaceholderText = "Select a file",
+                        },
+                        new FormBeatmapFileSelector(true)
+                        {
+                            Caption = "File selector with intermediate choice dialog",
+                            PlaceholderText = "Select a file",
                         },
                         new FormColourPalette
                         {

osu.Game/Beatmaps/Formats/LegacyBeatmapDecoder.cs

@@ -51,7 +51,7 @@ namespace osu.Game.Beatmaps.Formats
         }
 
         /// <summary>
-        /// Whether or not beatmap or runtime offsets should be applied. Defaults on; only disable for testing purposes.
+        /// Whether beatmap or runtime offsets should be applied. Defaults on; only disable for testing purposes.
         /// </summary>
         public bool ApplyOffsets = true;
 

osu.Game/Graphics/UserInterfaceV2/FormFileSelector.cs

@@ -242,20 +242,26 @@ namespace osu.Game.Graphics.UserInterfaceV2
 
         Task ICanAcceptFiles.Import(ImportTask[] tasks, ImportParameters parameters) => throw new NotImplementedException();
 
+        protected virtual FileChooserPopover CreatePopover(string[] handledExtensions, Bindable<FileInfo?> current, string? chooserPath) => new FileChooserPopover(handledExtensions, current, chooserPath);
+
         public Popover GetPopover()
         {
-            var popover = new FileChooserPopover(handledExtensions, Current, initialChooserPath);
+            var popover = CreatePopover(handledExtensions, Current, initialChooserPath);
             popoverState.UnbindBindings();
             popoverState.BindTo(popover.State);
             return popover;
         }
 
-        private partial class FileChooserPopover : OsuPopover
+        protected partial class FileChooserPopover : OsuPopover
         {
             protected override string PopInSampleName => "UI/overlay-big-pop-in";
             protected override string PopOutSampleName => "UI/overlay-big-pop-out";
 
-            public FileChooserPopover(string[] handledExtensions, Bindable<FileInfo?> currentFile, string? chooserPath)
+            private readonly Bindable<FileInfo?> current = new Bindable<FileInfo?>();
+
+            protected OsuFileSelector FileSelector;
+
+            public FileChooserPopover(string[] handledExtensions, Bindable<FileInfo?> current, string? chooserPath)
                 : base(false)
             {
                 Child = new Container
@@ -264,12 +270,13 @@ namespace osu.Game.Graphics.UserInterfaceV2
                     // simplest solution to avoid underlying text to bleed through the bottom border
                     // https://github.com/ppy/osu/pull/30005#issuecomment-2378884430
                     Padding = new MarginPadding { Bottom = 1 },
-                    Child = new OsuFileSelector(chooserPath, handledExtensions)
+                    Child = FileSelector = new OsuFileSelector(chooserPath, handledExtensions)
                     {
                         RelativeSizeAxes = Axes.Both,
-                        CurrentFile = { BindTarget = currentFile }
                     },
                 };
+
+                this.current.BindTo(current);
             }
 
             [BackgroundDependencyLoader]
@@ -292,6 +299,19 @@ namespace osu.Game.Graphics.UserInterfaceV2
                     }
                 });
             }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                FileSelector.CurrentFile.ValueChanged += f =>
+                {
+                    if (f.NewValue != null)
+                        OnFileSelected(f.NewValue);
+                };
+            }
+
+            protected virtual void OnFileSelected(FileInfo file) => current.Value = file;
         }
     }
 }

osu.Game/Localisation/EditorSetupStrings.cs

@@ -198,6 +198,21 @@ namespace osu.Game.Localisation
         /// </summary>
         public static LocalisableString ClickToSelectBackground => new TranslatableString(getKey(@"click_to_select_background"), @"Click to select a background image");
 
+        /// <summary>
+        /// "Apply this change to all difficulties?"
+        /// </summary>
+        public static LocalisableString ApplicationScopeSelectionTitle => new TranslatableString(getKey(@"application_scope_selection_title"), @"Apply this change to all difficulties?");
+
+        /// <summary>
+        /// "Apply to all difficulties"
+        /// </summary>
+        public static LocalisableString ApplyToAllDifficulties => new TranslatableString(getKey(@"apply_to_all_difficulties"), @"Apply to all difficulties");
+
+        /// <summary>
+        /// "Only apply to this difficulty"
+        /// </summary>
+        public static LocalisableString ApplyToThisDifficulty => new TranslatableString(getKey(@"apply_to_this_difficulty"), @"Only apply to this difficulty");
+
         /// <summary>
         /// "Ruleset ({0})"
         /// </summary>

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

@@ -0,0 +1,155 @@
+// 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.Diagnostics;
+using System.IO;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osu.Game.Graphics.UserInterfaceV2;
+using osu.Game.Overlays;
+using osuTK;
+using osu.Game.Localisation;
+
+namespace osu.Game.Screens.Edit.Setup
+{
+    /// <summary>
+    /// A type of <see cref="FormFileSelector"/> dedicated to beatmap resources.
+    /// </summary>
+    /// <remarks>
+    /// This expands on <see cref="FormFileSelector"/> by adding an intermediate step before finalisation
+    /// to choose whether the selected file should be applied to the current difficulty or all difficulties in the set,
+    /// the user's choice is saved in <see cref="ApplyToAllDifficulties"/> before the file selection is finalised and propagated to <see cref="FormFileSelector.Current"/>.
+    /// </remarks>
+    public partial class FormBeatmapFileSelector : FormFileSelector
+    {
+        private readonly bool beatmapHasMultipleDifficulties;
+
+        public readonly Bindable<bool> ApplyToAllDifficulties = new Bindable<bool>(true);
+
+        public FormBeatmapFileSelector(bool beatmapHasMultipleDifficulties, params string[] handledExtensions)
+            : base(handledExtensions)
+        {
+            this.beatmapHasMultipleDifficulties = beatmapHasMultipleDifficulties;
+        }
+
+        protected override FileChooserPopover CreatePopover(string[] handledExtensions, Bindable<FileInfo?> current, string? chooserPath)
+        {
+            var popover = new BeatmapFileChooserPopover(handledExtensions, current, chooserPath, beatmapHasMultipleDifficulties);
+            popover.ApplyToAllDifficulties.BindTo(ApplyToAllDifficulties);
+            return popover;
+        }
+
+        private partial class BeatmapFileChooserPopover : FileChooserPopover
+        {
+            private readonly bool beatmapHasMultipleDifficulties;
+
+            public readonly Bindable<bool> ApplyToAllDifficulties = new Bindable<bool>(true);
+
+            private Container selectApplicationScopeContainer = null!;
+
+            public BeatmapFileChooserPopover(string[] handledExtensions, Bindable<FileInfo?> current, string? chooserPath, bool beatmapHasMultipleDifficulties)
+                : base(handledExtensions, current, chooserPath)
+            {
+                this.beatmapHasMultipleDifficulties = beatmapHasMultipleDifficulties;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OverlayColourProvider colourProvider, OsuColour colours)
+            {
+                Add(selectApplicationScopeContainer = new InputBlockingContainer
+                {
+                    Alpha = 0f,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Colour = colourProvider.Background6.Opacity(0.9f),
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        new Container
+                        {
+                            Anchor = Anchor.Centre,
+                            Origin = Anchor.Centre,
+                            Masking = true,
+                            CornerRadius = 10f,
+                            AutoSizeAxes = Axes.Both,
+                            Children = new Drawable[]
+                            {
+                                new Box
+                                {
+                                    Colour = colourProvider.Background5,
+                                    RelativeSizeAxes = Axes.Both,
+                                },
+                                new FillFlowContainer
+                                {
+                                    Anchor = Anchor.Centre,
+                                    Origin = Anchor.Centre,
+                                    AutoSizeAxes = Axes.Both,
+                                    Direction = FillDirection.Vertical,
+                                    Spacing = new Vector2(0f, 10f),
+                                    Margin = new MarginPadding(30),
+                                    Children = new Drawable[]
+                                    {
+                                        new OsuSpriteText
+                                        {
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            Text = EditorSetupStrings.ApplicationScopeSelectionTitle,
+                                            Margin = new MarginPadding { Bottom = 20f },
+                                        },
+                                        new RoundedButton
+                                        {
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            Width = 300f,
+                                            Text = EditorSetupStrings.ApplyToAllDifficulties,
+                                            Action = () =>
+                                            {
+                                                ApplyToAllDifficulties.Value = true;
+                                                updateFileSelection();
+                                            },
+                                            BackgroundColour = colours.Red2,
+                                        },
+                                        new RoundedButton
+                                        {
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            Width = 300f,
+                                            Text = EditorSetupStrings.ApplyToThisDifficulty,
+                                            Action = () =>
+                                            {
+                                                ApplyToAllDifficulties.Value = false;
+                                                updateFileSelection();
+                                            },
+                                        },
+                                    }
+                                }
+                            }
+                        },
+                    }
+                });
+            }
+
+            protected override void OnFileSelected(FileInfo file)
+            {
+                if (beatmapHasMultipleDifficulties)
+                    selectApplicationScopeContainer.FadeIn(200, Easing.InQuint);
+                else
+                    base.OnFileSelected(file);
+            }
+
+            private void updateFileSelection()
+            {
+                Debug.Assert(FileSelector.CurrentFile.Value != null);
+                base.OnFileSelected(FileSelector.CurrentFile.Value);
+            }
+        }
+    }
+}

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

@@ -1,23 +1,25 @@
 // 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;
 using System.IO;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
-using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Overlays;
 using osu.Game.Localisation;
+using osu.Game.Models;
 using osu.Game.Utils;
 
 namespace osu.Game.Screens.Edit.Setup
 {
     public partial class ResourcesSection : SetupSection
     {
-        private FormFileSelector audioTrackChooser = null!;
-        private FormFileSelector backgroundChooser = null!;
+        private FormBeatmapFileSelector audioTrackChooser = null!;
+        private FormBeatmapFileSelector backgroundChooser = null!;
 
         public override LocalisableString Title => EditorSetupStrings.ResourcesHeader;
 
@@ -30,9 +32,6 @@ namespace osu.Game.Screens.Edit.Setup
         [Resolved]
         private IBindable<WorkingBeatmap> working { get; set; } = null!;
 
-        [Resolved]
-        private EditorBeatmap editorBeatmap { get; set; } = null!;
-
         [Resolved]
         private Editor? editor { get; set; }
 
@@ -47,14 +46,16 @@ namespace osu.Game.Screens.Edit.Setup
                 Height = 110,
             };
 
+            bool beatmapHasMultipleDifficulties = working.Value.BeatmapSetInfo.Beatmaps.Count > 1;
+
             Children = new Drawable[]
             {
-                backgroundChooser = new FormFileSelector(SupportedExtensions.IMAGE_EXTENSIONS)
+                backgroundChooser = new FormBeatmapFileSelector(beatmapHasMultipleDifficulties, SupportedExtensions.IMAGE_EXTENSIONS)
                 {
                     Caption = GameplaySettingsStrings.BackgroundHeader,
                     PlaceholderText = EditorSetupStrings.ClickToSelectBackground,
                 },
-                audioTrackChooser = new FormFileSelector(SupportedExtensions.AUDIO_EXTENSIONS)
+                audioTrackChooser = new FormBeatmapFileSelector(beatmapHasMultipleDifficulties, SupportedExtensions.AUDIO_EXTENSIONS)
                 {
                     Caption = EditorSetupStrings.AudioTrack,
                     PlaceholderText = EditorSetupStrings.ClickToSelectTrack,
@@ -73,75 +74,110 @@ namespace osu.Game.Screens.Edit.Setup
             audioTrackChooser.Current.BindValueChanged(audioTrackChanged);
         }
 
-        public bool ChangeBackgroundImage(FileInfo source)
+        public bool ChangeBackgroundImage(FileInfo source, bool applyToAllDifficulties)
         {
             if (!source.Exists)
                 return false;
 
-            var set = working.Value.BeatmapSetInfo;
+            changeResource(source, applyToAllDifficulties, @"bg",
+                metadata => metadata.BackgroundFile,
+                (metadata, name) => metadata.BackgroundFile = name);
 
-            var destination = new FileInfo($@"bg{source.Extension}");
-
-            // remove the previous background for now.
-            // in the future we probably want to check if this is being used elsewhere (other difficulties?)
-            var oldFile = set.GetFile(working.Value.Metadata.BackgroundFile);
-
-            using (var stream = source.OpenRead())
-            {
-                if (oldFile != null)
-                    beatmaps.DeleteFile(set, oldFile);
-
-                beatmaps.AddFile(set, stream, destination.Name);
-            }
-
-            editorBeatmap.SaveState();
-
-            working.Value.Metadata.BackgroundFile = destination.Name;
             headerBackground.UpdateBackground();
-
             editor?.ApplyToBackground(bg => bg.RefreshBackground());
-
             return true;
         }
 
-        public bool ChangeAudioTrack(FileInfo source)
+        public bool ChangeAudioTrack(FileInfo source, bool applyToAllDifficulties)
         {
             if (!source.Exists)
                 return false;
 
+            changeResource(source, applyToAllDifficulties, @"audio",
+                metadata => metadata.AudioFile,
+                (metadata, name) => metadata.AudioFile = name);
+
+            music.ReloadCurrentTrack();
+            return true;
+        }
+
+        private void changeResource(FileInfo source, bool applyToAllDifficulties, string baseFilename, Func<BeatmapMetadata, string> readFilename, Action<BeatmapMetadata, string> writeFilename)
+        {
             var set = working.Value.BeatmapSetInfo;
+            var beatmap = working.Value.BeatmapInfo;
 
-            var destination = new FileInfo($@"audio{source.Extension}");
+            var otherBeatmaps = set.Beatmaps.Where(b => !b.Equals(beatmap));
 
-            // remove the previous audio track for now.
-            // in the future we probably want to check if this is being used elsewhere (other difficulties?)
-            var oldFile = set.GetFile(working.Value.Metadata.AudioFile);
-
-            using (var stream = source.OpenRead())
+            // First, clean up files which will no longer be used.
+            if (applyToAllDifficulties)
             {
-                if (oldFile != null)
-                    beatmaps.DeleteFile(set, oldFile);
+                foreach (var b in set.Beatmaps)
+                {
+                    if (set.GetFile(readFilename(b.Metadata)) is RealmNamedFileUsage otherExistingFile)
+                        beatmaps.DeleteFile(set, otherExistingFile);
+                }
+            }
+            else
+            {
+                RealmNamedFileUsage? oldFile = set.GetFile(readFilename(working.Value.Metadata));
 
-                beatmaps.AddFile(set, stream, destination.Name);
+                if (oldFile != null)
+                {
+                    bool oldFileUsedInOtherDiff = otherBeatmaps
+                        .Any(b => readFilename(b.Metadata) == oldFile.Filename);
+                    if (!oldFileUsedInOtherDiff)
+                        beatmaps.DeleteFile(set, oldFile);
+                }
             }
 
-            working.Value.Metadata.AudioFile = destination.Name;
+            // Choose a new filename that doesn't clash with any other existing files.
+            string newFilename = $"{baseFilename}{source.Extension}";
 
-            editorBeatmap.SaveState();
-            music.ReloadCurrentTrack();
+            if (set.GetFile(newFilename) != null)
+            {
+                string[] existingFilenames = set.Files.Select(f => f.Filename).Where(f =>
+                    f.StartsWith(baseFilename, StringComparison.OrdinalIgnoreCase) &&
+                    f.EndsWith(source.Extension, StringComparison.OrdinalIgnoreCase)).ToArray();
+                newFilename = NamingUtils.GetNextBestFilename(existingFilenames, $@"{baseFilename}{source.Extension}");
+            }
 
-            return true;
+            using (var stream = source.OpenRead())
+                beatmaps.AddFile(set, stream, newFilename);
+
+            if (applyToAllDifficulties)
+            {
+                foreach (var b in otherBeatmaps)
+                {
+                    // This operation is quite expensive, so only perform it if required.
+                    if (readFilename(b.Metadata) == newFilename) continue;
+
+                    writeFilename(b.Metadata, newFilename);
+
+                    // save the difficulty to re-encode the .osu file, updating any reference of the old filename.
+                    //
+                    // note that this triggers a full save flow, including triggering a difficulty calculation.
+                    // this is not a cheap operation and should be reconsidered in the future.
+                    var beatmapWorking = beatmaps.GetWorkingBeatmap(b);
+                    beatmaps.Save(b, beatmapWorking.Beatmap, beatmapWorking.GetSkin());
+                }
+            }
+
+            writeFilename(beatmap.Metadata, newFilename);
+
+            // editor change handler cannot be aware of any file changes or other difficulties having their metadata modified.
+            // for simplicity's sake, trigger a save when changing any resource to ensure the change is correctly saved.
+            editor?.Save();
         }
 
         private void backgroundChanged(ValueChangedEvent<FileInfo?> file)
         {
-            if (file.NewValue == null || !ChangeBackgroundImage(file.NewValue))
+            if (file.NewValue == null || !ChangeBackgroundImage(file.NewValue, backgroundChooser.ApplyToAllDifficulties.Value))
                 backgroundChooser.Current.Value = file.OldValue;
         }
 
         private void audioTrackChanged(ValueChangedEvent<FileInfo?> file)
         {
-            if (file.NewValue == null || !ChangeAudioTrack(file.NewValue))
+            if (file.NewValue == null || !ChangeAudioTrack(file.NewValue, audioTrackChooser.ApplyToAllDifficulties.Value))
                 audioTrackChooser.Current.Value = file.OldValue;
         }
     }