Adds new keybind property: AllowSubCombs (#1473)

Co-authored-by: Radrark <null>

Robust.Client/Input/InputManager.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
@@ -134,7 +134,8 @@ namespace Robust.Client.Input
                     Priority = p.Priority,
                     Type = p.BindingType,
                     CanFocus = p.CanFocus,
-                    CanRepeat = p.CanRepeat
+                    CanRepeat = p.CanRepeat,
+                    AllowSubCombs = p.AllowSubCombs
                 }).ToArray();
 
             var leaveEmpty = _modifiedKeyFunctions
@@ -203,6 +204,7 @@ namespace Robust.Client.Input
 
             var bindsDown = new List<KeyBinding>();
             var hasCanFocus = false;
+            var hasAllowSubCombs = false;
 
             // bindings are ordered with larger combos before single key bindings so combos have priority.
             foreach (var binding in _bindings)
@@ -221,12 +223,22 @@ namespace Robust.Client.Input
                         matchedCombo = binding.PackedKeyCombo;
 
                         bindsDown.Add(binding);
+
                         hasCanFocus |= binding.CanFocus;
+                        hasAllowSubCombs |= binding.AllowSubCombs;
+
                     }
                     else if (PackedIsSubPattern(matchedCombo, binding.PackedKeyCombo))
                     {
-                        // kill any lower level matches
-                        UpBind(binding);
+                        if (hasAllowSubCombs)
+                        {
+                            bindsDown.Add(binding);
+                        }
+                        else
+                        {
+                            // kill any lower level matches
+                            UpBind(binding);
+                        }
                     }
                 }
             }
@@ -378,8 +390,8 @@ namespace Robust.Client.Input
         {
             for (var i = 0; i < 32; i += 8)
             {
-                var key = (Key) (subPackedCombo.Packed >> i);
-                if (!PackedContainsKey(packedCombo, key))
+                var key = (Key) ((subPackedCombo.Packed >> i) & 0b_1111_1111);
+                if (key != Key.Unknown && !PackedContainsKey(packedCombo, key))
                 {
                     return false;
                 }
@@ -453,7 +465,7 @@ namespace Robust.Client.Input
         public IKeyBinding RegisterBinding(BoundKeyFunction function, KeyBindingType bindingType,
             Key baseKey, Key? mod1, Key? mod2, Key? mod3)
         {
-            var binding = new KeyBinding(this, function, bindingType, baseKey, false, false,
+            var binding = new KeyBinding(this, function, bindingType, baseKey, false, false, false,
                 0, mod1 ?? Key.Unknown, mod2 ?? Key.Unknown, mod3 ?? Key.Unknown);
 
             RegisterBinding(binding);
@@ -464,7 +476,7 @@ namespace Robust.Client.Input
         public IKeyBinding RegisterBinding(in KeyBindingRegistration reg, bool markModified = true)
         {
             var binding = new KeyBinding(this, reg.Function, reg.Type, reg.BaseKey, reg.CanFocus, reg.CanRepeat,
-                reg.Priority, reg.Mod1, reg.Mod2, reg.Mod3);
+                reg.AllowSubCombs, reg.Priority, reg.Mod1, reg.Mod2, reg.Mod3);
 
             RegisterBinding(binding, markModified);
 
@@ -619,12 +631,18 @@ namespace Robust.Client.Input
             [ViewVariables]
             public bool CanRepeat { get; internal set; }
 
+            /// <summary>
+            ///     Whether the Bound Key Combination allows Sub Combinations of it to trigger.
+            /// </summary>
+            [ViewVariables]
+            public bool AllowSubCombs { get; internal set; }
+
             [ViewVariables] public int Priority { get; internal set; }
 
             public KeyBinding(InputManager inputManager, BoundKeyFunction function,
                 KeyBindingType bindingType,
                 Key baseKey,
-                bool canFocus, bool canRepeat, int priority, Key mod1 = Key.Unknown,
+                bool canFocus, bool canRepeat, bool allowSubCombs, int priority, Key mod1 = Key.Unknown,
                 Key mod2 = Key.Unknown,
                 Key mod3 = Key.Unknown)
             {
@@ -632,6 +650,7 @@ namespace Robust.Client.Input
                 BindingType = bindingType;
                 CanFocus = canFocus;
                 CanRepeat = canRepeat;
+                AllowSubCombs = allowSubCombs;
                 Priority = priority;
                 _inputManager = inputManager;
 

Robust.Client/Interfaces/Input/IKeyBinding.cs

@@ -16,6 +16,7 @@ namespace Robust.Client.Interfaces.Input
 
         bool CanFocus { get; }
         bool CanRepeat { get; }
+        bool AllowSubCombs { get; }
         int Priority { get; }
 
         /// <summary>

Robust.Client/Interfaces/Input/KeyBindingRegistration.cs

@@ -1,4 +1,4 @@
-using Robust.Client.Input;
+using Robust.Client.Input;
 using Robust.Shared.Input;
 using Robust.Shared.Interfaces.Serialization;
 using Robust.Shared.Serialization;
@@ -16,6 +16,7 @@ namespace Robust.Client.Interfaces.Input
         public int Priority;
         public bool CanFocus;
         public bool CanRepeat;
+        public bool AllowSubCombs;
 
         public void ExposeData(ObjectSerializer serializer)
         {
@@ -28,6 +29,7 @@ namespace Robust.Client.Interfaces.Input
             serializer.DataField(ref Priority, "priority", 0);
             serializer.DataField(ref CanFocus, "canFocus", false);
             serializer.DataField(ref CanRepeat, "canRepeat", false);
+            serializer.DataField(ref AllowSubCombs, "allowSubCombs", false);
         }
     }
 }