Merge 12 upstream ppy/osu commits (ours-priority)

osu.Android.props

@@ -99,7 +99,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.507.1" />
+    <PackageReference Include="ppy.osu.Framework.Android" Version="2026.508.1" />
     <!-- `ppy.osu.Framework.NativeLibs` is a transitive dependency of `ppy.osu.Framework`
          that ships desktop-only natives (Linux/macOS/Windows) under `runtimes/<rid>/native/`
          — including a bare Linux `libbass.so`/`libbass_fx.so`/`libbassmix.so` for linux-arm64.

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneManiaEditorSaving.cs

@@ -20,18 +20,18 @@ public partial class TestSceneManiaEditorSaving : EditorSavingTestScene
         [Test]
         public void TestKeyCountChange()
         {
-            FormSliderBar<float> keyCount = null!;
+            FormSliderBar<int> keyCount = null!;
 
             AddStep("go to setup screen", () => InputManager.Key(Key.F4));
-            AddUntilStep("retrieve key count slider", () => keyCount = Editor.ChildrenOfType<SetupScreen>().Single().ChildrenOfType<FormSliderBar<float>>().First(), () => Is.Not.Null);
+            AddUntilStep("retrieve key count slider", () => keyCount = Editor.ChildrenOfType<SetupScreen>().Single().ChildrenOfType<FormSliderBar<int>>().First(), () => Is.Not.Null);
             AddAssert("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));
             AddStep("change key count to 8", () =>
             {
                 keyCount.Current.Value = 8;
             });
             AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<SaveAndReloadEditorDialog>);
             AddStep("refuse", () => InputManager.Key(Key.Number2));
-            AddAssert("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));
+            AddUntilStep("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));
 
             AddStep("change key count to 8 again", () =>
             {
@@ -41,5 +41,32 @@ public void TestKeyCountChange()
             AddStep("acquiesce", () => InputManager.Key(Key.Number1));
             AddUntilStep("beatmap became 8K", () => Game.Beatmap.Value.BeatmapInfo.Difficulty.CircleSize, () => Is.EqualTo(8));
         }
+
+        [Test]
+        public void TestDualStagesChange()
+        {
+            FormCheckBox dualStages = null!;
+            FormSliderBar<int> keyCount = null!;
+
+            AddStep("go to setup screen", () => InputManager.Key(Key.F4));
+            AddUntilStep("retrieve dual stages checkbox", () => dualStages = Editor.ChildrenOfType<SetupScreen>().Single().ChildrenOfType<FormCheckBox>().First(), () => Is.Not.Null);
+            AddUntilStep("retrieve key count slider", () => keyCount = Editor.ChildrenOfType<SetupScreen>().Single().ChildrenOfType<FormSliderBar<int>>().First(), () => Is.Not.Null);
+            AddAssert("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));
+            AddStep("set dual stages", () =>
+            {
+                dualStages.Current.Value = true;
+            });
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().SingleOrDefault()?.CurrentDialog, Is.InstanceOf<SaveAndReloadEditorDialog>);
+            AddStep("refuse", () => InputManager.Key(Key.Number2));
+            AddUntilStep("key count is 5", () => keyCount.Current.Value, () => Is.EqualTo(5));
+
+            AddStep("set dual stages again", () =>
+            {
+                dualStages.Current.Value = true;
+            });
+            AddUntilStep("dialog visible", () => Game.ChildrenOfType<IDialogOverlay>().Single().CurrentDialog, Is.InstanceOf<SaveAndReloadEditorDialog>);
+            AddStep("acquiesce", () => InputManager.Key(Key.Number1));
+            AddUntilStep("beatmap became 12K", () => Game.Beatmap.Value.BeatmapInfo.Difficulty.CircleSize, () => Is.EqualTo(12));
+        }
     }
 }

osu.Game.Rulesets.Mania.Tests/Editor/TestSceneObjectPlacement.cs

@@ -57,6 +57,28 @@ public void TestNoSeekOnNotePlacement()
             AddAssert("time is unchanged", () => EditorClock.CurrentTime, () => Is.EqualTo(initialTime));
         }
 
+        [Test]
+        public void TestNoTwoObjectsAtSameTimeAndColumn()
+        {
+            AddStep("change seek setting to false", () => config.SetValue(OsuSetting.EditorAutoSeekOnPlacement, false));
+            AddStep("clear beatmap", () => EditorBeatmap.Clear());
+
+            AddStep("select note placement tool", () => InputManager.Key(Key.Number2));
+            AddStep("move mouse to centre of last column", () => InputManager.MoveMouseTo(this.ChildrenOfType<Column>().Last().ScreenSpaceDrawQuad.Centre));
+            AddStep("place note", () => InputManager.Click(MouseButton.Left));
+            AddAssert("beatmap has 1 object", () => EditorBeatmap.HitObjects, () => Has.Count.EqualTo(1));
+
+            AddStep("select note placement tool", () => InputManager.Key(Key.Number2));
+            AddStep("move mouse to centre of first column", () => InputManager.MoveMouseTo(this.ChildrenOfType<Column>().First().ScreenSpaceDrawQuad.Centre));
+            AddStep("place note", () => InputManager.Click(MouseButton.Left));
+            AddAssert("beatmap has 2 objects", () => EditorBeatmap.HitObjects, () => Has.Count.EqualTo(2));
+
+            AddStep("select note placement tool", () => InputManager.Key(Key.Number2));
+            AddStep("move mouse to centre of last column", () => InputManager.MoveMouseTo(this.ChildrenOfType<Column>().Last().ScreenSpaceDrawQuad.Centre));
+            AddStep("place note", () => InputManager.Click(MouseButton.Left));
+            AddAssert("beatmap has 2 objects", () => EditorBeatmap.HitObjects, () => Has.Count.EqualTo(2));
+        }
+
         private void placeObject()
         {
             AddStep("select note placement tool", () => InputManager.Key(Key.Number2));

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

@@ -7,6 +7,7 @@
 using osu.Framework.Graphics;
 using osu.Framework.Localisation;
 using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.Formats;
 using osu.Game.Graphics.UserInterfaceV2;
 using osu.Game.Localisation;
 using osu.Game.Resources.Localisation.Web;
@@ -19,13 +20,22 @@ public partial class ManiaDifficultySection : SetupSection
     {
         public override LocalisableString Title => EditorSetupStrings.DifficultyHeader;
 
-        private FormSliderBar<float> keyCountSlider { get; set; } = null!;
+        private FormSliderBar<int> keyCountSlider { get; set; } = null!;
+        private FormCheckBox dualStages { get; set; } = null!;
         private FormCheckBox specialStyle { get; set; } = null!;
         private FormSliderBar<float> healthDrainSlider { get; set; } = null!;
         private FormSliderBar<float> overallDifficultySlider { get; set; } = null!;
         private FormSliderBar<double> baseVelocitySlider { get; set; } = null!;
         private FormSliderBar<double> tickRateSlider { get; set; } = null!;
 
+        private readonly BindableInt singleStageKeyCount = new BindableInt
+        {
+            Default = (int)BeatmapDifficulty.DEFAULT_DIFFICULTY,
+            Precision = 1,
+        };
+
+        private readonly BindableInt actualKeyCount = new BindableInt();
+
         [Resolved]
         private Editor? editor { get; set; }
 
@@ -37,20 +47,19 @@ private void load()
         {
             Children = new Drawable[]
             {
-                keyCountSlider = new FormSliderBar<float>
+                keyCountSlider = new FormSliderBar<int>
                 {
                     Caption = BeatmapsetsStrings.ShowStatsCsMania,
                     HintText = "The number of columns in the beatmap",
-                    Current = new BindableFloat(Beatmap.Difficulty.CircleSize)
-                    {
-                        Default = BeatmapDifficulty.DEFAULT_DIFFICULTY,
-                        MinValue = 0,
-                        MaxValue = 10,
-                        Precision = 1,
-                    },
+                    Current = singleStageKeyCount,
                     TransferValueOnCommit = true,
                     TabbableContentContainer = this,
                 },
+                dualStages = new FormCheckBox
+                {
+                    Caption = "Dual stages",
+                    HintText = "Doubles the number of keys by adding a second stage."
+                },
                 specialStyle = new FormCheckBox
                 {
                     Caption = "Use special (N+1) style",
@@ -117,16 +126,54 @@ private void load()
                 },
             };
 
-            keyCountSlider.Current.BindValueChanged(updateKeyCount);
+            setStateFromActualKeyCount((int)Beatmap.Difficulty.CircleSize);
+
+            keyCountSlider.Current.BindValueChanged(_ => calculateActualKeyCount());
+            dualStages.Current.BindValueChanged(_ =>
+            {
+                updateSingleStageKeyCountBounds();
+                calculateActualKeyCount();
+            });
+            actualKeyCount.BindValueChanged(updateKeyCount);
+
             healthDrainSlider.Current.BindValueChanged(_ => updateValues());
             overallDifficultySlider.Current.BindValueChanged(_ => updateValues());
             baseVelocitySlider.Current.BindValueChanged(_ => updateValues());
             tickRateSlider.Current.BindValueChanged(_ => updateValues());
         }
 
+        private void updateSingleStageKeyCountBounds()
+        {
+            singleStageKeyCount.MinValue = dualStages.Current.Value ? ManiaRuleset.MAX_STAGE_KEYS / 2 + 1 : 1;
+            singleStageKeyCount.MaxValue = dualStages.Current.Value ? LegacyBeatmapDecoder.MAX_MANIA_KEY_COUNT / 2 : ManiaRuleset.MAX_STAGE_KEYS;
+        }
+
+        private void setStateFromActualKeyCount(int keyCount)
+        {
+            actualKeyCount.Value = keyCount;
+
+            if (keyCount > 10)
+            {
+                dualStages.Current.Value = true;
+                singleStageKeyCount.Value = keyCount / 2;
+            }
+            else
+            {
+                dualStages.Current.Value = false;
+                singleStageKeyCount.Value = keyCount;
+            }
+
+            updateSingleStageKeyCountBounds();
+        }
+
+        private void calculateActualKeyCount()
+        {
+            actualKeyCount.Value = keyCountSlider.Current.Value * (dualStages.Current.Value ? 2 : 1);
+        }
+
         private bool updatingKeyCount;
 
-        private void updateKeyCount(ValueChangedEvent<float> keyCount)
+        private void updateKeyCount(ValueChangedEvent<int> keyCount)
         {
             if (updatingKeyCount) return;
 
@@ -143,7 +190,8 @@ private void updateKeyCount(ValueChangedEvent<float> keyCount)
                     Schedule(() =>
                     {
                         changeHandler!.RestoreState(-1);
-                        Beatmap.Difficulty.CircleSize = keyCountSlider.Current.Value = keyCount.OldValue;
+                        Beatmap.Difficulty.CircleSize = keyCount.OldValue;
+                        setStateFromActualKeyCount(keyCount.OldValue);
                         updatingKeyCount = false;
                     });
                 }
@@ -158,7 +206,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.Difficulty.CircleSize = actualKeyCount.Value;
             Beatmap.SpecialStyle = specialStyle.Current.Value;
             Beatmap.Difficulty.DrainRate = healthDrainSlider.Current.Value;
             Beatmap.Difficulty.OverallDifficulty = overallDifficultySlider.Current.Value;

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -485,6 +485,22 @@ public override IEnumerable<RulesetBeatmapAttribute> GetBeatmapAttributesForDisp
             };
         }
 
+        public override IEnumerable<RulesetBeatmapAttribute> GetBeatmapAttributesForRankedPlayCard(IBeatmapInfo beatmapInfo, IReadOnlyCollection<Mod> mods)
+        {
+            var attributes = GetBeatmapAttributesForDisplay(beatmapInfo, mods).ToList();
+
+            // Key count attribute isn't relevant to ranked play (it's decided by the pool).
+            attributes.RemoveAll(a => a.Acronym == "KC");
+
+            float holdNoteRatio = beatmapInfo.TotalObjectCount == 0 ? 0 : (float)beatmapInfo.EndTimeObjectCount / beatmapInfo.TotalObjectCount;
+            attributes.Insert(0, new RulesetBeatmapAttribute("Hold notes", @"HN", holdNoteRatio, holdNoteRatio, 1)
+            {
+                ValueFormat = "P0"
+            });
+
+            return attributes;
+        }
+
         public override IRulesetFilterCriteria CreateRulesetFilterCriteria()
         {
             return new ManiaFilterCriteria();

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

@@ -73,6 +73,12 @@ public void TestHitCircleSnapsToSliderEnd()
 
             AddStep("end slider placement", () => InputManager.Click(MouseButton.Right));
 
+            AddStep("seek to slider end", () =>
+            {
+                var slider = (Slider)EditorBeatmap.HitObjects.Single();
+                EditorClock.Seek(slider.EndTime);
+            });
+
             AddStep("enter circle placement mode", () => InputManager.Key(Key.Number2));
 
             AddStep("move mouse slightly", () => InputManager.MoveMouseTo(playfield.ScreenSpaceDrawQuad.Centre + new Vector2(playfield.ScreenSpaceDrawQuad.Width * 0.205f, 0)));

osu.Game.Tests/Extensions/NumberFormattingExtensionsTest.cs

@@ -51,7 +51,15 @@ public string TestDouble(double input, bool percent, int decimalDigits)
         [TestCase(0.4, true, 2, ExpectedResult = "40%")]
         [TestCase(1e-6, false, 6, ExpectedResult = "0,000001")]
         [TestCase(0.48333, true, 4, ExpectedResult = "48,33%")]
-        public string TestCultureSensitivity(double input, bool percent, int decimalDigits)
+        public string TestCultureSensitivityDecimalPoint(double input, bool percent, int decimalDigits)
+        {
+            return input.ToStandardFormattedString(decimalDigits, percent);
+        }
+
+        [Test]
+        [SetCulture("sv-SE")]
+        [TestCase(-1e-6, false, 6, ExpectedResult = "−0,000001")]
+        public string TestCultureSensitivityNegativeSign(double input, bool percent, int decimalDigits)
         {
             return input.ToStandardFormattedString(decimalDigits, percent);
         }