Merge pull request #8809 from smoogipoo/mania-10k-single-stage

Allow 10k to be played on a single stage

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

@@ -47,7 +47,7 @@ namespace osu.Game.Rulesets.Mania.Beatmaps
             {
                 TargetColumns = (int)Math.Max(1, roundedCircleSize);
 
-                if (TargetColumns >= 10)
+                if (TargetColumns > ManiaRuleset.MAX_STAGE_KEYS)
                 {
                     TargetColumns /= 2;
                     Dual = true;

osu.Game.Rulesets.Mania/DualStageVariantGenerator.cs

@@ -0,0 +1,64 @@
+// 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.Collections.Generic;
+using System.Linq;
+using osu.Framework.Input.Bindings;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class DualStageVariantGenerator
+    {
+        private readonly int singleStageVariant;
+        private readonly InputKey[] stage1LeftKeys;
+        private readonly InputKey[] stage1RightKeys;
+        private readonly InputKey[] stage2LeftKeys;
+        private readonly InputKey[] stage2RightKeys;
+
+        public DualStageVariantGenerator(int singleStageVariant)
+        {
+            this.singleStageVariant = singleStageVariant;
+
+            // 10K is special because it expands towards the centre of the keyboard (VM/BN), rather than towards the edges of the keyboard.
+            if (singleStageVariant == 10)
+            {
+                stage1LeftKeys = new[] { InputKey.Q, InputKey.W, InputKey.E, InputKey.R, InputKey.V };
+                stage1RightKeys = new[] { InputKey.M, InputKey.I, InputKey.O, InputKey.P, InputKey.BracketLeft };
+
+                stage2LeftKeys = new[] { InputKey.S, InputKey.D, InputKey.F, InputKey.G, InputKey.B };
+                stage2RightKeys = new[] { InputKey.N, InputKey.J, InputKey.K, InputKey.L, InputKey.Semicolon };
+            }
+            else
+            {
+                stage1LeftKeys = new[] { InputKey.Q, InputKey.W, InputKey.E, InputKey.R };
+                stage1RightKeys = new[] { InputKey.I, InputKey.O, InputKey.P, InputKey.BracketLeft };
+
+                stage2LeftKeys = new[] { InputKey.S, InputKey.D, InputKey.F, InputKey.G };
+                stage2RightKeys = new[] { InputKey.J, InputKey.K, InputKey.L, InputKey.Semicolon };
+            }
+        }
+
+        public IEnumerable<KeyBinding> GenerateMappings()
+        {
+            var stage1Bindings = new VariantMappingGenerator
+            {
+                LeftKeys = stage1LeftKeys,
+                RightKeys = stage1RightKeys,
+                SpecialKey = InputKey.V,
+                SpecialAction = ManiaAction.Special1,
+                NormalActionStart = ManiaAction.Key1
+            }.GenerateKeyBindingsFor(singleStageVariant, out var nextNormal);
+
+            var stage2Bindings = new VariantMappingGenerator
+            {
+                LeftKeys = stage2LeftKeys,
+                RightKeys = stage2RightKeys,
+                SpecialKey = InputKey.B,
+                SpecialAction = ManiaAction.Special2,
+                NormalActionStart = nextNormal
+            }.GenerateKeyBindingsFor(singleStageVariant, out _);
+
+            return stage1Bindings.Concat(stage2Bindings);
+        }
+    }
+}

osu.Game.Rulesets.Mania/ManiaInputManager.cs

@@ -78,5 +78,11 @@ namespace osu.Game.Rulesets.Mania
 
         [Description("Key 18")]
         Key18,
+
+        [Description("Key 19")]
+        Key19,
+
+        [Description("Key 20")]
+        Key20,
     }
 }

osu.Game.Rulesets.Mania/ManiaRuleset.cs

@@ -35,6 +35,11 @@ namespace osu.Game.Rulesets.Mania
 {
     public class ManiaRuleset : Ruleset, ILegacyRuleset
     {
+        /// <summary>
+        /// The maximum number of supported keys in a single stage.
+        /// </summary>
+        public const int MAX_STAGE_KEYS = 10;
+
         public override DrawableRuleset CreateDrawableRulesetWith(IBeatmap beatmap, IReadOnlyList<Mod> mods = null) => new DrawableManiaRuleset(this, beatmap, mods);
 
         public override ScoreProcessor CreateScoreProcessor() => new ManiaScoreProcessor();
@@ -202,6 +207,7 @@ namespace osu.Game.Rulesets.Mania
                             new ManiaModKey7(),
                             new ManiaModKey8(),
                             new ManiaModKey9(),
+                            new ManiaModKey10(),
                             new ManiaModKey1(),
                             new ManiaModKey2(),
                             new ManiaModKey3()),
@@ -250,9 +256,9 @@ namespace osu.Game.Rulesets.Mania
         {
             get
             {
-                for (int i = 1; i <= 9; i++)
+                for (int i = 1; i <= MAX_STAGE_KEYS; i++)
                     yield return (int)PlayfieldType.Single + i;
-                for (int i = 2; i <= 18; i += 2)
+                for (int i = 2; i <= MAX_STAGE_KEYS * 2; i += 2)
                     yield return (int)PlayfieldType.Dual + i;
             }
         }
@@ -262,73 +268,10 @@ namespace osu.Game.Rulesets.Mania
             switch (getPlayfieldType(variant))
             {
                 case PlayfieldType.Single:
-                    return new VariantMappingGenerator
+                    return new SingleStageVariantGenerator(variant).GenerateMappings();
-                    {
-                        LeftKeys = new[]
-                        {
-                            InputKey.A,
-                            InputKey.S,
-                            InputKey.D,
-                            InputKey.F
-                        },
-                        RightKeys = new[]
-                        {
-                            InputKey.J,
-                            InputKey.K,
-                            InputKey.L,
-                            InputKey.Semicolon
-                        },
-                        SpecialKey = InputKey.Space,
-                        SpecialAction = ManiaAction.Special1,
-                        NormalActionStart = ManiaAction.Key1,
-                    }.GenerateKeyBindingsFor(variant, out _);
 
                 case PlayfieldType.Dual:
-                    int keys = getDualStageKeyCount(variant);
+                    return new DualStageVariantGenerator(getDualStageKeyCount(variant)).GenerateMappings();
-
-                    var stage1Bindings = new VariantMappingGenerator
-                    {
-                        LeftKeys = new[]
-                        {
-                            InputKey.Q,
-                            InputKey.W,
-                            InputKey.E,
-                            InputKey.R,
-                        },
-                        RightKeys = new[]
-                        {
-                            InputKey.X,
-                            InputKey.C,
-                            InputKey.V,
-                            InputKey.B
-                        },
-                        SpecialKey = InputKey.S,
-                        SpecialAction = ManiaAction.Special1,
-                        NormalActionStart = ManiaAction.Key1
-                    }.GenerateKeyBindingsFor(keys, out var nextNormal);
-
-                    var stage2Bindings = new VariantMappingGenerator
-                    {
-                        LeftKeys = new[]
-                        {
-                            InputKey.Number7,
-                            InputKey.Number8,
-                            InputKey.Number9,
-                            InputKey.Number0
-                        },
-                        RightKeys = new[]
-                        {
-                            InputKey.K,
-                            InputKey.L,
-                            InputKey.Semicolon,
-                            InputKey.Quote
-                        },
-                        SpecialKey = InputKey.I,
-                        SpecialAction = ManiaAction.Special2,
-                        NormalActionStart = nextNormal
-                    }.GenerateKeyBindingsFor(keys, out _);
-
-                    return stage1Bindings.Concat(stage2Bindings);
             }
 
             return Array.Empty<KeyBinding>();
@@ -364,59 +307,6 @@ namespace osu.Game.Rulesets.Mania
         {
             return (PlayfieldType)Enum.GetValues(typeof(PlayfieldType)).Cast<int>().OrderByDescending(i => i).First(v => variant >= v);
         }
-
-        private class VariantMappingGenerator
-        {
-            /// <summary>
-            /// All the <see cref="InputKey"/>s available to the left hand.
-            /// </summary>
-            public InputKey[] LeftKeys;
-
-            /// <summary>
-            /// All the <see cref="InputKey"/>s available to the right hand.
-            /// </summary>
-            public InputKey[] RightKeys;
-
-            /// <summary>
-            /// The <see cref="InputKey"/> for the special key.
-            /// </summary>
-            public InputKey SpecialKey;
-
-            /// <summary>
-            /// The <see cref="ManiaAction"/> at which the normal columns should begin.
-            /// </summary>
-            public ManiaAction NormalActionStart;
-
-            /// <summary>
-            /// The <see cref="ManiaAction"/> for the special column.
-            /// </summary>
-            public ManiaAction SpecialAction;
-
-            /// <summary>
-            /// Generates a list of <see cref="KeyBinding"/>s for a specific number of columns.
-            /// </summary>
-            /// <param name="columns">The number of columns that need to be bound.</param>
-            /// <param name="nextNormalAction">The next <see cref="ManiaAction"/> to use for normal columns.</param>
-            /// <returns>The keybindings.</returns>
-            public IEnumerable<KeyBinding> GenerateKeyBindingsFor(int columns, out ManiaAction nextNormalAction)
-            {
-                ManiaAction currentNormalAction = NormalActionStart;
-
-                var bindings = new List<KeyBinding>();
-
-                for (int i = LeftKeys.Length - columns / 2; i < LeftKeys.Length; i++)
-                    bindings.Add(new KeyBinding(LeftKeys[i], currentNormalAction++));
-
-                if (columns % 2 == 1)
-                    bindings.Add(new KeyBinding(SpecialKey, SpecialAction));
-
-                for (int i = 0; i < columns / 2; i++)
-                    bindings.Add(new KeyBinding(RightKeys[i], currentNormalAction++));
-
-                nextNormalAction = currentNormalAction;
-                return bindings;
-            }
-        }
     }
 
     public enum PlayfieldType

osu.Game.Rulesets.Mania/Mods/ManiaModKey10.cs

@@ -0,0 +1,13 @@
+// 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.
+
+namespace osu.Game.Rulesets.Mania.Mods
+{
+    public class ManiaModKey10 : ManiaKeyMod
+    {
+        public override int KeyCount => 10;
+        public override string Name => "Ten Keys";
+        public override string Acronym => "10K";
+        public override string Description => @"Play with ten keys.";
+    }
+}

osu.Game.Rulesets.Mania/SingleStageVariantGenerator.cs

@@ -0,0 +1,41 @@
+// 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.Collections.Generic;
+using osu.Framework.Input.Bindings;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class SingleStageVariantGenerator
+    {
+        private readonly int variant;
+        private readonly InputKey[] leftKeys;
+        private readonly InputKey[] rightKeys;
+
+        public SingleStageVariantGenerator(int variant)
+        {
+            this.variant = variant;
+
+            // 10K is special because it expands towards the centre of the keyboard (V/N), rather than towards the edges of the keyboard.
+            if (variant == 10)
+            {
+                leftKeys = new[] { InputKey.A, InputKey.S, InputKey.D, InputKey.F, InputKey.V };
+                rightKeys = new[] { InputKey.N, InputKey.J, InputKey.K, InputKey.L, InputKey.Semicolon };
+            }
+            else
+            {
+                leftKeys = new[] { InputKey.A, InputKey.S, InputKey.D, InputKey.F };
+                rightKeys = new[] { InputKey.J, InputKey.K, InputKey.L, InputKey.Semicolon };
+            }
+        }
+
+        public IEnumerable<KeyBinding> GenerateMappings() => new VariantMappingGenerator
+        {
+            LeftKeys = leftKeys,
+            RightKeys = rightKeys,
+            SpecialKey = InputKey.Space,
+            SpecialAction = ManiaAction.Special1,
+            NormalActionStart = ManiaAction.Key1,
+        }.GenerateKeyBindingsFor(variant, out _);
+    }
+}

osu.Game.Rulesets.Mania/VariantMappingGenerator.cs

@@ -0,0 +1,61 @@
+// 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.Collections.Generic;
+using osu.Framework.Input.Bindings;
+
+namespace osu.Game.Rulesets.Mania
+{
+    public class VariantMappingGenerator
+    {
+        /// <summary>
+        /// All the <see cref="InputKey"/>s available to the left hand.
+        /// </summary>
+        public InputKey[] LeftKeys;
+
+        /// <summary>
+        /// All the <see cref="InputKey"/>s available to the right hand.
+        /// </summary>
+        public InputKey[] RightKeys;
+
+        /// <summary>
+        /// The <see cref="InputKey"/> for the special key.
+        /// </summary>
+        public InputKey SpecialKey;
+
+        /// <summary>
+        /// The <see cref="ManiaAction"/> at which the normal columns should begin.
+        /// </summary>
+        public ManiaAction NormalActionStart;
+
+        /// <summary>
+        /// The <see cref="ManiaAction"/> for the special column.
+        /// </summary>
+        public ManiaAction SpecialAction;
+
+        /// <summary>
+        /// Generates a list of <see cref="KeyBinding"/>s for a specific number of columns.
+        /// </summary>
+        /// <param name="columns">The number of columns that need to be bound.</param>
+        /// <param name="nextNormalAction">The next <see cref="ManiaAction"/> to use for normal columns.</param>
+        /// <returns>The keybindings.</returns>
+        public IEnumerable<KeyBinding> GenerateKeyBindingsFor(int columns, out ManiaAction nextNormalAction)
+        {
+            ManiaAction currentNormalAction = NormalActionStart;
+
+            var bindings = new List<KeyBinding>();
+
+            for (int i = LeftKeys.Length - columns / 2; i < LeftKeys.Length; i++)
+                bindings.Add(new KeyBinding(LeftKeys[i], currentNormalAction++));
+
+            if (columns % 2 == 1)
+                bindings.Add(new KeyBinding(SpecialKey, SpecialAction));
+
+            for (int i = 0; i < columns / 2; i++)
+                bindings.Add(new KeyBinding(RightKeys[i], currentNormalAction++));
+
+            nextNormalAction = currentNormalAction;
+            return bindings;
+        }
+    }
+}