Merge branch 'CoplayDev:main' into main

Author: dsarno

MCPForUnity/Editor/Tools/JsonUtil.cs

@@ -0,0 +1,32 @@
+using Newtonsoft.Json.Linq;
+using UnityEngine;
+
+namespace MCPForUnity.Editor.Tools
+{
+    internal static class JsonUtil
+    {
+        /// <summary>
+        /// If @params[paramName] is a JSON string, parse it to a JObject in-place.
+        /// Logs a warning on parse failure and leaves the original value.
+        /// </summary>
+        internal static void CoerceJsonStringParameter(JObject @params, string paramName)
+        {
+            if (@params == null || string.IsNullOrEmpty(paramName)) return;
+            var token = @params[paramName];
+            if (token != null && token.Type == JTokenType.String)
+            {
+                try
+                {
+                    var parsed = JObject.Parse(token.ToString());
+                    @params[paramName] = parsed;
+                }
+                catch (Newtonsoft.Json.JsonReaderException e)
+                {
+                    Debug.LogWarning($"[MCP] Could not parse '{paramName}' JSON string: {e.Message}");
+                }
+            }
+        }
+    }
+}
+
+

MCPForUnity/Editor/Tools/JsonUtil.cs.meta

@@ -63,6 +63,21 @@ public static object HandleCommand(JObject @params)
             // Common parameters
             string path = @params["path"]?.ToString();
 
+            // Coerce string JSON to JObject for 'properties' if provided as a JSON string
+            var propertiesToken = @params["properties"];
+            if (propertiesToken != null && propertiesToken.Type == JTokenType.String)
+            {
+                try
+                {
+                    var parsed = JObject.Parse(propertiesToken.ToString());
+                    @params["properties"] = parsed;
+                }
+                catch (Exception e)
+                {
+                    Debug.LogWarning($"[ManageAsset] Could not parse 'properties' JSON string: {e.Message}");
+                }
+            }
+
             try
             {
                 switch (action)
@@ -999,7 +1014,108 @@ private static bool ApplyMaterialProperties(Material mat, JObject properties)
                 }
             }
 
-            // TODO: Add handlers for other property types (Vectors, Ints, Keywords, RenderQueue, etc.)
+			// --- Flexible direct property assignment ---
+			// Allow payloads like: { "_Color": [r,g,b,a] }, { "_Glossiness": 0.5 }, { "_MainTex": "Assets/.." }
+			// while retaining backward compatibility with the structured keys above.
+			// This iterates all top-level keys except the reserved structured ones and applies them
+			// if they match known shader properties.
+			var reservedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "shader", "color", "float", "texture" };
+
+			// Helper resolves common URP/Standard aliasing (e.g., _Color <-> _BaseColor, _MainTex <-> _BaseMap, _Glossiness <-> _Smoothness)
+			string ResolvePropertyName(string name)
+			{
+				if (string.IsNullOrEmpty(name)) return name;
+				string[] candidates;
+				switch (name)
+				{
+					case "_Color": candidates = new[] { "_Color", "_BaseColor" }; break;
+					case "_BaseColor": candidates = new[] { "_BaseColor", "_Color" }; break;
+					case "_MainTex": candidates = new[] { "_MainTex", "_BaseMap" }; break;
+					case "_BaseMap": candidates = new[] { "_BaseMap", "_MainTex" }; break;
+					case "_Glossiness": candidates = new[] { "_Glossiness", "_Smoothness" }; break;
+					case "_Smoothness": candidates = new[] { "_Smoothness", "_Glossiness" }; break;
+					default: candidates = new[] { name }; break;
+				}
+				foreach (var candidate in candidates)
+				{
+					if (mat.HasProperty(candidate)) return candidate;
+				}
+				return name; // fall back to original
+			}
+
+			foreach (var prop in properties.Properties())
+			{
+				if (reservedKeys.Contains(prop.Name)) continue;
+				string shaderProp = ResolvePropertyName(prop.Name);
+				JToken v = prop.Value;
+
+				// Color: numeric array [r,g,b,(a)]
+				if (v is JArray arr && arr.Count >= 3 && arr.All(t => t.Type == JTokenType.Float || t.Type == JTokenType.Integer))
+				{
+					if (mat.HasProperty(shaderProp))
+					{
+						try
+						{
+							var c = new Color(
+								arr[0].ToObject<float>(),
+								arr[1].ToObject<float>(),
+								arr[2].ToObject<float>(),
+								arr.Count > 3 ? arr[3].ToObject<float>() : 1f
+							);
+							if (mat.GetColor(shaderProp) != c)
+							{
+								mat.SetColor(shaderProp, c);
+								modified = true;
+							}
+						}
+						catch (Exception ex)
+						{
+							Debug.LogWarning($"Error setting color '{shaderProp}': {ex.Message}");
+						}
+					}
+					continue;
+				}
+
+				// Float: single number
+				if (v.Type == JTokenType.Float || v.Type == JTokenType.Integer)
+				{
+					if (mat.HasProperty(shaderProp))
+					{
+						try
+						{
+							float f = v.ToObject<float>();
+							if (!Mathf.Approximately(mat.GetFloat(shaderProp), f))
+							{
+								mat.SetFloat(shaderProp, f);
+								modified = true;
+							}
+						}
+						catch (Exception ex)
+						{
+							Debug.LogWarning($"Error setting float '{shaderProp}': {ex.Message}");
+						}
+					}
+					continue;
+				}
+
+				// Texture: string path
+				if (v.Type == JTokenType.String)
+				{
+					string texPath = v.ToString();
+					if (!string.IsNullOrEmpty(texPath) && mat.HasProperty(shaderProp))
+					{
+						var tex = AssetDatabase.LoadAssetAtPath<Texture>(AssetPathUtility.SanitizeAssetPath(texPath));
+						if (tex != null && mat.GetTexture(shaderProp) != tex)
+						{
+							mat.SetTexture(shaderProp, tex);
+							modified = true;
+						}
+					}
+					continue;
+				}
+			}
+
+			// TODO: Add handlers for other property types (Vectors, Ints, Keywords, RenderQueue, etc.)
             return modified;
         }
 

MCPForUnity/Editor/Tools/ManageAsset.cs

@@ -66,6 +66,21 @@ public static object HandleCommand(JObject @params)
             bool includeNonPublicSerialized = @params["includeNonPublicSerialized"]?.ToObject<bool>() ?? true; // Default to true
             // --- End add parameter ---
 
+            // Coerce string JSON to JObject for 'componentProperties' if provided as a JSON string
+            var componentPropsToken = @params["componentProperties"];
+            if (componentPropsToken != null && componentPropsToken.Type == JTokenType.String)
+            {
+                try
+                {
+                    var parsed = JObject.Parse(componentPropsToken.ToString());
+                    @params["componentProperties"] = parsed;
+                }
+                catch (Exception e)
+                {
+                    Debug.LogWarning($"[ManageGameObject] Could not parse 'componentProperties' JSON string: {e.Message}");
+                }
+            }
+
             // --- Prefab Redirection Check ---
             string targetPath =
                 targetToken?.Type == JTokenType.String ? targetToken.ToString() : null;

MCPForUnity/Editor/Tools/ManageGameObject.cs

@@ -1,6 +1,6 @@
 [project]
 name = "MCPForUnityServer"
-version = "6.2.4"
+version = "6.2.5"
 description = "MCP for Unity Server: A Unity package for Unity Editor integration via the Model Context Protocol (MCP)."
 readme = "README.md"
 requires-python = ">=3.10"

MCPForUnity/UnityMcpServer~/src/pyproject.toml

@@ -1 +1 @@
-6.2.4
+6.2.5

MCPForUnity/UnityMcpServer~/src/server_version.txt

@@ -2,6 +2,7 @@
 Defines the manage_asset tool for interacting with Unity assets.
 """
 import asyncio
+import json
 from typing import Annotated, Any, Literal
 
 from fastmcp import Context
@@ -33,6 +34,14 @@ async def manage_asset(
     page_number: Annotated[int | float | str, "Page number for pagination"] | None = None
 ) -> dict[str, Any]:
     ctx.info(f"Processing manage_asset: {action}")
+    # Coerce 'properties' from JSON string to dict for client compatibility
+    if isinstance(properties, str):
+        try:
+            properties = json.loads(properties)
+            ctx.info("manage_asset: coerced properties from JSON string to dict")
+        except Exception as e:
+            ctx.warn(f"manage_asset: failed to parse properties JSON string: {e}")
+            # Leave properties as-is; Unity side may handle defaults
     # Ensure properties is a dict if None
     if properties is None:
         properties = {}

MCPForUnity/UnityMcpServer~/src/tools/manage_asset.py

@@ -1,3 +1,4 @@
+import json
 from typing import Annotated, Any, Literal
 
 from fastmcp import Context
@@ -42,7 +43,7 @@ def manage_gameobject(
     layer: Annotated[str, "Layer name"] | None = None,
     components_to_remove: Annotated[list[str],
                                     "List of component names to remove"] | None = None,
-    component_properties: Annotated[dict[str, dict[str, Any]],
+    component_properties: Annotated[dict[str, dict[str, Any]] | str,
                                     """Dictionary of component names to their properties to set. For example:
                                     `{"MyScript": {"otherObject": {"find": "Player", "method": "by_name"}}}` assigns GameObject
                                     `{"MyScript": {"playerHealth": {"find": "Player", "component": "HealthComponent"}}}` assigns Component
@@ -65,7 +66,7 @@ def manage_gameobject(
                                           "Controls whether serialization of private [SerializeField] fields is included (accepts true/false or 'true'/'false')"] | None = None,
 ) -> dict[str, Any]:
     ctx.info(f"Processing manage_gameobject: {action}")
-    
+
     # Coercers to tolerate stringified booleans and vectors
     def _coerce_bool(value, default=None):
         if value is None:
@@ -113,6 +114,16 @@ def _to_vec3(parts):
     search_inactive = _coerce_bool(search_inactive)
     includeNonPublicSerialized = _coerce_bool(includeNonPublicSerialized)
 
+    # Coerce 'component_properties' from JSON string to dict for client compatibility
+    if isinstance(component_properties, str):
+        try:
+            component_properties = json.loads(component_properties)
+            ctx.info("manage_gameobject: coerced component_properties from JSON string to dict")
+        except json.JSONDecodeError as e:
+            return {"success": False, "message": f"Invalid JSON in component_properties: {e}"}
+    # Ensure final type is a dict (object) if provided
+    if component_properties is not None and not isinstance(component_properties, dict):
+        return {"success": False, "message": "component_properties must be a JSON object (dict)."}
     try:
         # Map tag to search_term when search_method is by_tag for backward compatibility
         if action == "find" and search_method == "by_tag" and tag is not None and search_term is None: