FIX: ISXB-1674 - Input actions asset not converted correctly when upgrading from 1.14.1 (Regression)

Assets/Tests/InputSystem.Editor/CustomProcessorEnumTest.cs

@@ -108,5 +108,31 @@
 
  yield return null;
  }
+
+ [UnityTest]
+ public IEnumerator Migration_FromLegacyJson_ShouldConvertOrdinal_KeepInvertVector2_AndSeparators()
+ {
+ var legacyJson = m_Asset.ToJson().Replace("\"version\": 1", "\"version\": 0").Replace("Custom(SomeEnum=10)", "Custom(SomeEnum=1)");
+
+ // Add a trailing processor to verify the semicolon separator is preserved.
+ if (!legacyJson.Contains(";InvertVector2(invertX=true)"))
+ legacyJson = legacyJson.Replace("Custom(SomeEnum=1)\"", "Custom(SomeEnum=1);InvertVector2(invertX=true)\"");
+
+ var migratedAsset = InputActionAsset.FromJson(legacyJson);
+ Assume.That(migratedAsset, Is.Not.Null, "Failed to load legacy JSON into an InputActionAsset.");
+
+ var migratedJson = migratedAsset.ToJson();
+ Assume.That(migratedJson, Is.Not.Null.And.Not.Empty, "Migrated JSON was empty.");
+
+ Assert.Less(migratedJson.IndexOf("InvertVector2(invertX=true)", StringComparison.Ordinal), migratedJson.IndexOf(",Custom(SomeEnum=20)", StringComparison.Ordinal),
+ "Expected a comma between the first and second processors, with InvertVector2 first."
+ );
+
+ Assert.Greater(migratedJson.IndexOf(";InvertVector2(invertX=true)", StringComparison.Ordinal), migratedJson.IndexOf("Custom(SomeEnum=20)", StringComparison.Ordinal),
+ "Expected a semicolon between the second and third processors, with the trailing InvertVector2 last."
+ );
+
+ yield return null;
+ }
 }
 #endif

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

@@ -3,7 +3,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
-using UnityEngine.InputSystem.Editor;
+using System.Globalization;
 using UnityEngine.InputSystem.Utilities;
 
 ////TODO: make the FindAction logic available on any IEnumerable<InputAction> and IInputActionCollection via extension methods
@@ -1014,60 +1014,125 @@
  {
  if (parsedJson.version >= JsonVersion.Version1)
  return;
- if ((parsedJson.maps?.Length ?? 0) > 0 && (parsedJson.version) < JsonVersion.Version1)
+
+ if (parsedJson.maps == null || parsedJson.maps.Length == 0)
+ {
+ parsedJson.version = JsonVersion.Version1;
+ return;
+ }
+
+ for (var mi = 0; mi < parsedJson.maps.Length; ++mi)
  {
- for (var mi = 0; mi < parsedJson.maps.Length; ++mi)
+ var mapJson = parsedJson.maps[mi];
+ if (mapJson.actions == null || mapJson.actions.Length == 0)
+ continue;
+
+ for (var ai = 0; ai < mapJson.actions.Length; ++ai)
  {
- var mapJson = parsedJson.maps[mi];
- for (var ai = 0; ai < mapJson.actions.Length; ++ai)
+ var actionJson = mapJson.actions[ai];
+ var raw = actionJson.processors;
+ if (string.IsNullOrEmpty(raw))
+ continue;
+
+ var parts = System.Text.RegularExpressions.Regex.Split(raw, @"\s*([,;])\s*");
+ if (parts.Length == 0)
+ continue;
+
+ var tokens = new List<string>();
+ for (int i = 0; i < parts.Length; i += 2)
+ if (!string.IsNullOrEmpty(parts[i]))
+ tokens.Add(parts[i]);
+
+ if (tokens.Count == 0)
+ continue;
+
+ var parsed = new List<NameAndParameters>(tokens.Count);
+ foreach (var t in tokens)
+ parsed.Add(NameAndParameters.Parse(t));
+
+ var rebuiltTokens = new List<string>(tokens.Count);
+ var anyProcessorChanged = false;
+
+ for (int pi = 0; pi < parsed.Count; pi++)
  {
- var actionJson = mapJson.actions[ai];
- var raw = actionJson.processors;
- if (string.IsNullOrEmpty(raw))
+ var nap = parsed[pi];
+
+ var procType = InputSystem.TryGetProcessor(nap.name);
+ if (procType == null || nap.parameters.Count == 0)
+ {
+ rebuiltTokens.Add(tokens[pi]);
  continue;
+ }
+
+ var dict = new Dictionary<string, string>(nap.parameters.Count, System.StringComparer.OrdinalIgnoreCase);
+ foreach (var p in nap.parameters)
+ dict[p.name] = p.value.ToString();
+
+ var changedThisProcessor = false;
 
- var list = NameAndParameters.ParseMultiple(raw).ToList();
- var rebuilt = new List<string>(list.Count);
- foreach (var nap in list)
+ foreach (var field in procType.GetFields(BindingFlags.Public | BindingFlags.Instance))
  {
- var procType = InputSystem.TryGetProcessor(nap.name);
- if (nap.parameters.Count == 0 || procType == null)
- {
-  rebuilt.Add(nap.ToString());
+ if (!field.FieldType.IsEnum)
+  continue;
+
+ if (!dict.TryGetValue(field.Name, out var rawVal))
  continue;
- }
 
- var dict = nap.parameters.ToDictionary(p => p.name, p => p.value.ToString());
- var anyChanged = false;
- foreach (var field in procType.GetFields(BindingFlags.Public | BindingFlags.Instance).Where(f => f.FieldType.IsEnum))
+ if (int.TryParse(rawVal, NumberStyles.Integer, CultureInfo.InvariantCulture, out var n))
  {
- if (dict.TryGetValue(field.Name, out var ordS) && int.TryParse(ordS, out var ord))
+ var values = System.Enum.GetValues(field.FieldType);
+ var looksLikeOrdinal = n >= 0 && n < values.Length && !System.Enum.IsDefined(field.FieldType, n);
+ if (looksLikeOrdinal)
  {
- var values = Enum.GetValues(field.FieldType).Cast<object>().ToArray();
- if (ord >= 0 && ord < values.Length)
+ var underlying = Convert.ToInt32(values.GetValue(n));
+ if (underlying != n)
  {
- dict[field.Name] = Convert.ToInt32(values[ord]).ToString();
- anyChanged = true;
+ dict[field.Name] = underlying.ToString(CultureInfo.InvariantCulture);
+ changedThisProcessor = true;
  }
  }
  }
+ }
+
+ if (!changedThisProcessor)
+ {
+ rebuiltTokens.Add(tokens[pi]);
+ }
+ else
+ {
+ var ordered = nap.parameters.Select(p =>
+ {
+ var v = dict.TryGetValue(p.name, out var nv) ? nv : p.value.ToString();
+ return $"{p.name}={v}";
+ });
+
+ var migrated = $"{nap.name}({string.Join(",", ordered)})";
+ rebuiltTokens.Add(migrated);
+ anyProcessorChanged = true;
+ }
+ }
 
- if (!anyChanged)
+ if (anyProcessorChanged)
+ {
+ var sb = new System.Text.StringBuilder(raw.Length + 16);
+ int tokenIndex = 0;
+ for (int partIndex = 0; partIndex < parts.Length; ++partIndex)
+ {
+ if ((partIndex % 2) == 0)
  {
- rebuilt.Add(nap.ToString());
+ if (tokenIndex < rebuiltTokens.Count)
+ sb.Append(rebuiltTokens[tokenIndex++]);
  }
  else
  {
- var paramText = string.Join(",", dict.Select(kv => $"{kv.Key}={kv.Value}"));
- rebuilt.Add($"{nap.name}({paramText})");
+ sb.Append(parts[partIndex]);
  }
  }
-
- actionJson.processors = string.Join(";", rebuilt);
- mapJson.actions[ai] = actionJson;
+ actionJson.processors = sb.ToString();
  }
- parsedJson.maps[mi] = mapJson;
+ mapJson.actions[ai] = actionJson;
  }
+ parsedJson.maps[mi] = mapJson;
  }
  // Bump the version so we never re-migrate
  parsedJson.version = JsonVersion.Version1;