use instanceID as main key

Add long entityID for lossless convertion

Author: Thaina

MCPForUnity/Editor/Tools/Animation/ControllerCreate.cs

@@ -4,6 +4,7 @@
 using System.Linq;
 using Newtonsoft.Json.Linq;
 using MCPForUnity.Editor.Helpers;
+using MCPForUnity.Runtime.Helpers;
 using UnityEditor;
 using UnityEditor.Animations;
 using UnityEngine;
@@ -423,9 +424,11 @@ public static object AssignToGameObject(JObject @params)
         }
 
         // Reads node graph positions for every state (recurses into sub-state-machines).
-        // Returns [{ name, x, y, layer }] so a caller can analyze the current layout
-        // before sending back a revised one. Pass 'layerIndex' to scope to one layer;
-        // results are paged (page_size/cursor) since controllers can have many states.
+        // Returns [{ name, instanceId, x, y, layer }] so a caller can analyze the current
+        // layout before sending back a revised one. 'instanceId' round-trips into
+        // set_state_positions for an unambiguous match (duplicate names are fine).
+        // Pass 'layerIndex' to scope to one layer; results are paged (page_size/cursor)
+        // since controllers can have many states.
         public static object GetStatePositions(JObject @params)
         {
             var controller = LoadController(@params);
@@ -470,6 +473,7 @@ private static void CollectPositions(AnimatorStateMachine sm, int layer, List<ob
                 outList.Add(new
                 {
                     name = children[i].state.name,
+                    instanceId = children[i].state.GetInstanceIDLongCompat(),
                     x = children[i].position.x,
                     y = children[i].position.y,
                     layer
@@ -478,41 +482,39 @@ private static void CollectPositions(AnimatorStateMachine sm, int layer, List<ob
                 CollectPositions(sub.stateMachine, layer, outList);
         }
 
-        // Sets node graph positions from a 'positions' array of { name, x, y, layer? }.
-        // Each entry's optional 'layer' (falling back to a top-level 'layerIndex') scopes
-        // the match to one layer, so a name reused across layers is no longer ambiguous;
-        // entries with no layer match that name on any layer. Recurses into sub-state-
-        // machines and reassigns stateMachine.states so the edits persist on the asset.
+        // Sets node graph positions from a 'positions' array of { instanceId, x, y }.
+        // States are matched by 'instanceId' (from get_state_positions) for an exact,
+        // unambiguous hit even when names repeat across layers or sub-state-machines.
+        // Recurses into sub-state-machines and reassigns stateMachine.states so the
+        // edits persist on the asset.
         public static object SetStatePositions(JObject @params)
         {
             var controller = LoadController(@params);
             if (controller == null)
                 return ControllerNotFoundError(@params);
 
             if (!(@params["positions"] is JArray positions) || positions.Count == 0)
-                return new { success = false, message = "'positions' array is required: [{ name, x, y, layer? }, ...]" };
+                return new { success = false, message = "'positions' array is required: [{ instanceId, x, y }, ...]" };
 
-            int? defaultLayer = @params["layerIndex"]?.ToObject<int>();
-
-            // Key is "layer:name" when scoped to a layer, else "*:name" to match any layer.
-            var want = new Dictionary<string, Vector2>();
+            var want = new Dictionary<ulong, Vector2>();
             foreach (var token in positions)
             {
-                string name = token["name"]?.ToString();
-                if (string.IsNullOrEmpty(name))
+                if (!(token is JObject entry))
+                    continue;
+                ulong? instanceId = entry["instanceId"]?.ToObject<ulong>();
+                if (!instanceId.HasValue)
                     continue;
-                float x = token["x"]?.ToObject<float>() ?? 0f;
-                float y = token["y"]?.ToObject<float>() ?? 0f;
-                int? layer = token["layer"]?.ToObject<int>() ?? defaultLayer;
-                want[$"{(layer.HasValue ? layer.Value.ToString() : "*")}:{name}"] = new Vector2(x, y);
+                float x = entry["x"]?.ToObject<float>() ?? 0f;
+                float y = entry["y"]?.ToObject<float>() ?? 0f;
+                want[instanceId.Value] = new Vector2(x, y);
             }
             if (want.Count == 0)
-                return new { success = false, message = "No valid entries in 'positions' (each needs a 'name')." };
+                return new { success = false, message = "No valid entries in 'positions' (each needs an 'instanceId')." };
 
-            var matched = new HashSet<string>();
+            var matched = new HashSet<ulong>();
             Undo.RecordObject(controller, "Set State Positions");
             for (int li = 0; li < controller.layers.Length; li++)
-                ApplyPositions(controller.layers[li].stateMachine, li, want, matched);
+                ApplyPositions(controller.layers[li].stateMachine, want, matched);
 
             EditorUtility.SetDirty(controller);
             AssetDatabase.SaveAssets();
@@ -521,7 +523,7 @@ public static object SetStatePositions(JObject @params)
             return new
             {
                 success = true,
-                message = $"Positioned {matched.Count} state(s); {unmatched.Count} key(s) unmatched.",
+                message = $"Positioned {matched.Count} state(s); {unmatched.Count} id(s) unmatched.",
                 data = new
                 {
                     matched = matched.Count,
@@ -531,27 +533,22 @@ public static object SetStatePositions(JObject @params)
             };
         }
 
-        private static void ApplyPositions(AnimatorStateMachine sm, int layer, Dictionary<string, Vector2> want, HashSet<string> matched)
+        private static void ApplyPositions(AnimatorStateMachine sm, Dictionary<ulong, Vector2> want, HashSet<ulong> matched)
         {
             var children = sm.states;
             for (int i = 0; i < children.Length; i++)
             {
-                string name = children[i].state.name;
-                // Prefer a layer-scoped entry; fall back to the any-layer entry.
-                string scopedKey = $"{layer}:{name}";
-                string anyKey = $"*:{name}";
-                string key = want.ContainsKey(scopedKey) ? scopedKey
-                           : want.ContainsKey(anyKey) ? anyKey : null;
-                if (key != null)
+                ulong? id = children[i].state.GetInstanceIDLongCompat();
+                if (id.HasValue && want.TryGetValue(id.Value, out var p))
                 {
-                    children[i].position = new Vector3(want[key].x, want[key].y, 0f);
-                    matched.Add(key);
+                    children[i].position = new Vector3(p.x, p.y, 0f);
+                    matched.Add(id.Value);
                 }
             }
             sm.states = children; // reassign so position edits persist
 
             foreach (var sub in sm.stateMachines)
-                ApplyPositions(sub.stateMachine, layer, want, matched);
+                ApplyPositions(sub.stateMachine, want, matched);
         }
 
         private static AnimatorController LoadController(JObject @params)

MCPForUnity/Runtime/Helpers/UnityObjectIdCompat.cs

@@ -12,7 +12,9 @@ namespace MCPForUnity.Runtime.Helpers
     /// Version-gated wrappers for the InstanceID ↔ EntityId migration introduced in Unity 6.5
     /// and tightened in 6.6.
     ///   Forward (Object → int): <see cref="GetInstanceIDCompat"/>
+    ///   Forward (Object → ulong, lossless): <see cref="GetInstanceIDLongCompat"/>
     ///   Reverse (int → Object, Editor-only): <see cref="InstanceIDToObjectCompat"/>
+    ///   Reverse (ulong → Object, Editor-only): <see cref="InstanceIDToObjectLongCompat"/>
     /// </summary>
     public static class UnityObjectIdCompat
     {
@@ -36,6 +38,27 @@ public static int GetInstanceIDCompat(this Object obj)
 #endif
         }
 
+        /// <summary>
+        /// Like <see cref="GetInstanceIDCompat"/> but returns the full handle without the
+        /// lossy int truncation: on 6.5+ the EntityId's underlying ulong, on older versions
+        /// the int instance ID widened to ulong. Returns null for a null object. Use when
+        /// the handle must round-trip exactly (e.g. matching the same object back across a
+        /// JSON request).
+        /// </summary>
+        public static ulong? GetInstanceIDLongCompat(this Object obj)
+        {
+            if (obj == null)
+            {
+                return null;
+            }
+
+#if UNITY_6000_5_OR_NEWER
+            return EntityId.ToULong(obj.GetEntityId());
+#else
+            return unchecked((ulong)obj.GetInstanceID());
+#endif
+        }
+
 #if UNITY_EDITOR
 #if UNITY_6000_6_OR_NEWER
         private static MethodInfo _instanceIdToObject;
@@ -68,6 +91,24 @@ public static Object InstanceIDToObjectCompat(int instanceId)
             return EditorUtility.EntityIdToObject(instanceId);
 #else
             return EditorUtility.InstanceIDToObject(instanceId);
+#endif
+        }
+
+        /// <summary>
+        /// Resolves a ulong handle (from <see cref="GetInstanceIDLongCompat"/>) back to a
+        /// UnityEngine.Object. Disambiguates by Unity version, not by inspecting the numeric
+        /// range — a wrapped-negative int and a genuine 64-bit EntityId can occupy the same
+        /// high band, so range checks cannot tell them apart.
+        ///   6.5+    : the handle is the EntityId's ulong — resolve via EntityId.FromULong.
+        ///   Pre-6.5 : the handle is an int instance ID round-tripped through an unchecked
+        ///             ulong cast (negatives are valid) — cast back and use the int resolver.
+        /// </summary>
+        public static Object InstanceIDToObjectLongCompat(ulong instanceId)
+        {
+#if UNITY_6000_5_OR_NEWER
+            return EditorUtility.EntityIdToObject(EntityId.FromULong(instanceId));
+#else
+            return InstanceIDToObjectCompat(unchecked((int)instanceId));
 #endif
         }
 #endif

Server/tests/test_manage_animation.py

@@ -184,21 +184,16 @@ def test_get_state_positions_forwards_paging_and_layer(self):
         assert params["properties"]["cursor"] == 20
 
     def test_set_state_positions_forwards_positions(self):
-        positions = [{"name": "Idle", "x": 100, "y": 0}, {"name": "Walk", "x": 300, "y": 0}]
+        # instanceId round-trips from get_state_positions; can exceed 32-bit on Unity 6.5+
+        # (EntityId), and JSON / Python int carry the full 64-bit value losslessly.
+        positions = [{"instanceId": 8412, "x": 100, "y": 0},
+                     {"instanceId": 18446744073709551000, "x": 300, "y": 0}]
         _, params = self._dispatch(
             "controller_set_state_positions", properties={"positions": positions}
         )
         assert params["action"] == "controller_set_state_positions"
         assert params["properties"]["positions"] == positions
-
-    def test_set_state_positions_forwards_layer_scoping(self):
-        positions = [{"name": "Idle", "x": 0, "y": 0, "layer": 1}]
-        _, params = self._dispatch(
-            "controller_set_state_positions",
-            properties={"positions": positions, "layerIndex": 0},
-        )
-        assert params["properties"]["positions"][0]["layer"] == 1
-        assert params["properties"]["layerIndex"] == 0
+        assert params["properties"]["positions"][1]["instanceId"] == 18446744073709551000
 
 
 # =============================================================================