FIX: Fixed a bug within InputActionAsset.cs that prevented actions containing slashes to be found by name.

Author: ekcoh

Assets/Tests/InputSystem/CoreTests_Actions.cs

@@ -4780,6 +4780,7 @@ public void Actions_CanLookUpActionInMap()
 
         var action1 = map.AddAction("action1");
         var action2 = map.AddAction("action2");
+        var yawPitch = map.AddAction("Yaw/Pitch");
 
         Assert.That(map.FindAction("action1"), Is.SameAs(action1));
         Assert.That(map.FindAction("action2"), Is.SameAs(action2));
@@ -4788,6 +4789,10 @@ public void Actions_CanLookUpActionInMap()
         // Lookup is case-insensitive.
         Assert.That(map.FindAction("Action1"), Is.SameAs(action1));
         Assert.That(map.FindAction("Action2"), Is.SameAs(action2));
+
+        // Lookup allows '/' within action name (https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1306)
+        // yawPitchAction = _actions.FindAction("Yaw/Pitch");
+        Assert.That(map.FindAction("Yaw/Pitch"), Is.SameAs(yawPitch));
     }
 
     [Test]
@@ -7917,6 +7922,7 @@ public void Actions_CanLookUpActionInAssetByName()
         var action1 = map1.AddAction("action1");
         var action2 = map1.AddAction("action2");
         var action3 = map2.AddAction("action3");
+        var action4 = map2.AddAction("Yaw/Pitch");
 
         Assert.That(asset.FindAction("action1"), Is.SameAs(action1));
         Assert.That(asset.FindAction("action2"), Is.SameAs(action2));
@@ -7930,6 +7936,10 @@ public void Actions_CanLookUpActionInAssetByName()
         Assert.That(asset.FindAction($"{{{action2.id.ToString()}}}"), Is.SameAs(action2));
         Assert.That(asset.FindAction($"{{{action3.id.ToString()}}}"), Is.SameAs(action3));
 
+        // Lookup allows '/' within action name (https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1306)
+        // yawPitchAction = _actions.FindAction("Yaw/Pitch");
+        Assert.That(asset.FindAction("Yaw/Pitch"), Is.SameAs(action4));
+
         // Shouldn't allocate.
         var map1action1 = "map1/action1";
         Assert.That(() =>
@@ -7938,6 +7948,26 @@ public void Actions_CanLookUpActionInAssetByName()
         }, Is.Not.AllocatingGCMemory());
     }
 
+    // https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1306
+    [Test]
+    [Category("Actions")]
+    public void Actions_CanLookUpActionInAssetByNameIfHavingActionAndMapActionWithSameName()
+    {
+        var asset = ScriptableObject.CreateInstance<InputActionAsset>();
+
+        var map1 = new InputActionMap("map1");
+        var map2 = new InputActionMap("Yaw");
+
+        asset.AddActionMap(map1);
+        asset.AddActionMap(map2);
+
+        var action1 = map1.AddAction("Yaw/Pitch");
+        var action2 = map2.AddAction("Pitch");
+
+        // map/action should be selected first
+        Assert.That(asset.FindAction("Yaw/Pitch"), Is.SameAs(action2));
+    }
+
     // Since we allow looking up by action name without any map qualification, ambiguities result when several
     // actions are named the same. We choose to not do anything special other than generally preferring an
     // enabled action over a disabled one. Other than that, we just return the first hit.

Packages/com.unity.inputsystem/InputSystem/Actions/InputActionAsset.cs

@@ -471,7 +471,7 @@ public static InputActionAsset FromJson(string json)
         /// in the asset.
         /// </summary>
         /// <param name="actionNameOrId">Name of the action as either a "map/action" combination (e.g. "gameplay/fire") or
-        /// a simple name. In the former case, the name is split at the '/' slash and the first part is used to find
+        /// a simple name e.g. "fire". In the former case, the name is split at the '/' slash and the first part is used to find
         /// a map with that name and the second part is used to find an action with that name inside the map. In the
         /// latter case, all maps are searched in order and the first action that has the given name in any of the maps
         /// is returned. Note that name comparisons are case-insensitive.
@@ -491,6 +491,10 @@ public static InputActionAsset FromJson(string json)
         /// An exception is if, of the multiple actions with the same name, some are enabled and some are disabled. In
         /// this case, the first action that is enabled is returned.
         ///
+        /// If an action name contains a slash "/", e.g. "yaw/pitch" and there is also a map called "yaw" which
+        /// contains an action "pitch", the action "pitch" within the map "jump" will be returned instead of the
+        /// action named "yaw/pitch".
+        ///
         /// <example>
         /// <code>
         /// var asset = ScriptableObject.CreateInstance&lt;InputActionAsset&gt;();
@@ -533,28 +537,11 @@ public InputAction FindAction(string actionNameOrId, bool throwIfNotFound = fals
 
             if (m_ActionMaps != null)
             {
-                // Check if we have a "map/action" path.
+                // Check if we have a "map/action" path. If we do we either has a "map/action" path or a simple
+                // action name containing a slash. We first attempt matching it to a "map/action" and only if that
+                // fails do we attempt to search for a "some/action" name.
                 var indexOfSlash = actionNameOrId.IndexOf('/');
-                if (indexOfSlash == -1)
-                {
-                    // No slash so it's just a simple action name. Return either first enabled action or, if
-                    // none are enabled, first action with the given name.
-                    InputAction firstActionFound = null;
-                    for (var i = 0; i < m_ActionMaps.Length; ++i)
-                    {
-                        var action = m_ActionMaps[i].FindAction(actionNameOrId);
-                        if (action != null)
-                        {
-                            if (action.enabled || action.m_Id == actionNameOrId) // Match by ID is always exact.
-                                return action;
-                            if (firstActionFound == null)
-                                firstActionFound = action;
-                        }
-                    }
-                    if (firstActionFound != null)
-                        return firstActionFound;
-                }
-                else
+                if (indexOfSlash >= 0)
                 {
                     // Have a path. First search for the map, then for the action.
                     var mapName = new Substring(actionNameOrId, 0, indexOfSlash);
@@ -583,6 +570,23 @@ public InputAction FindAction(string actionNameOrId, bool throwIfNotFound = fals
                         break;
                     }
                 }
+
+                // It's just a simple action name. Return either first enabled action or, if
+                // none are enabled, first action with the given name.
+                InputAction firstActionFound = null;
+                for (var i = 0; i < m_ActionMaps.Length; ++i)
+                {
+                    var action = m_ActionMaps[i].FindAction(actionNameOrId);
+                    if (action != null)
+                    {
+                        if (action.enabled || action.m_Id == actionNameOrId) // Match by ID is always exact.
+                            return action;
+                        if (firstActionFound == null)
+                            firstActionFound = action;
+                    }
+                }
+                if (firstActionFound != null)
+                    return firstActionFound;
             }
 
             if (throwIfNotFound)