Merge pull request #983 from Scriptwonder/beta

Manage_physics

Author: Scriptwonder

MCPForUnity/Editor/Services/Server/TerminalLauncher.cs

@@ -70,14 +70,13 @@ public System.Diagnostics.ProcessStartInfo CreateTerminalProcessStartInfo(string
                 CreateNoWindow = true
             };
 #else
-            // Linux: Try common terminal emulators
-            // We use bash -c to execute the command, so we must properly quote/escape for bash
-            // Escape single quotes for the inner bash string
-            string escapedCommandLinux = command.Replace("'", "'\\''");
-            // Wrap the command in single quotes for bash -c
-            string script = $"'{escapedCommandLinux}; exec bash'";
-            // Escape double quotes for the outer Process argument string
-            string escapedScriptForArg = script.Replace("\"", "\\\"");
+            // Linux: Try common terminal emulators.
+            // ProcessStartInfo passes the argument string directly to the terminal, so we only
+            // need to escape for the double-quoted bash -c payload — no inner single quotes.
+            string script = $"{command}; exec bash";
+            string escapedScriptForArg = script
+                .Replace("\\", "\\\\")
+                .Replace("\"", "\\\"");
             string bashCmdArgs = $"bash -c \"{escapedScriptForArg}\"";
 
             string[] terminals = { "gnome-terminal", "xterm", "konsole", "xfce4-terminal" };

MCPForUnity/Editor/Tools/Build/BuildRunner.cs

@@ -111,7 +111,7 @@ private static void RunBuildCore(BuildJob job, Func<BuildReport> buildFunc)
                 else
                 {
                     job.State = BuildJobState.Failed;
-#if UNITY_2022_3_OR_NEWER
+#if UNITY_2023_1_OR_NEWER
                     job.ErrorMessage = report.SummarizeErrors();
 #else
                     job.ErrorMessage = $"Build failed with result: {summary.result}";

MCPForUnity/Editor/Tools/Physics.meta

@@ -0,0 +1,128 @@
+using System.Collections.Generic;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+using UnityEngine;
+using MCPForUnity.Editor.Helpers;
+
+namespace MCPForUnity.Editor.Tools.Physics
+{
+    internal static class CollisionMatrixOps
+    {
+        public static object GetCollisionMatrix(JObject @params)
+        {
+            var p = new ToolParams(@params);
+            string dimension = (p.Get("dimension") ?? "3d").ToLowerInvariant();
+
+            if (dimension != "3d" && dimension != "2d")
+                return new ErrorResponse($"Invalid dimension: '{dimension}'. Use '3d' or '2d'.");
+
+            var layers = new List<object>();
+            var populatedIndices = new List<int>();
+
+            for (int i = 0; i < 32; i++)
+            {
+                string name = LayerMask.LayerToName(i);
+                if (string.IsNullOrEmpty(name)) continue;
+                layers.Add(new { index = i, name });
+                populatedIndices.Add(i);
+            }
+
+            var matrix = new Dictionary<string, Dictionary<string, bool>>();
+
+            foreach (int i in populatedIndices)
+            {
+                string nameA = LayerMask.LayerToName(i);
+                var row = new Dictionary<string, bool>();
+
+                foreach (int j in populatedIndices)
+                {
+                    if (j > i) continue;
+                    string nameB = LayerMask.LayerToName(j);
+                    bool collides = dimension == "2d"
+                        ? !Physics2D.GetIgnoreLayerCollision(i, j)
+                        : !UnityEngine.Physics.GetIgnoreLayerCollision(i, j);
+                    row[nameB] = collides;
+                }
+
+                matrix[nameA] = row;
+            }
+
+            return new
+            {
+                success = true,
+                message = $"Collision matrix retrieved ({dimension}).",
+                data = new { layers, matrix }
+            };
+        }
+
+        public static object SetCollisionMatrix(JObject @params)
+        {
+            var p = new ToolParams(@params);
+            string dimension = (p.Get("dimension") ?? "3d").ToLowerInvariant();
+
+            if (dimension != "3d" && dimension != "2d")
+                return new ErrorResponse($"Invalid dimension: '{dimension}'. Use '3d' or '2d'.");
+
+            var layerAToken = p.GetRaw("layer_a");
+            var layerBToken = p.GetRaw("layer_b");
+
+            if (layerAToken == null)
+                return new ErrorResponse("'layer_a' parameter is required.");
+            if (layerBToken == null)
+                return new ErrorResponse("'layer_b' parameter is required.");
+
+            int layerA = ResolveLayer(layerAToken);
+            int layerB = ResolveLayer(layerBToken);
+
+            if (layerA < 0 || layerA >= 32)
+                return new ErrorResponse($"Invalid layer_a: '{layerAToken}'. Layer not found or out of range.");
+            if (layerB < 0 || layerB >= 32)
+                return new ErrorResponse($"Invalid layer_b: '{layerBToken}'. Layer not found or out of range.");
+
+            bool collide = p.GetBool("collide", true);
+
+            if (dimension == "2d")
+            {
+                Physics2D.IgnoreLayerCollision(layerA, layerB, !collide);
+                MarkSettingsDirty("ProjectSettings/Physics2DSettings.asset");
+            }
+            else
+            {
+                UnityEngine.Physics.IgnoreLayerCollision(layerA, layerB, !collide);
+                MarkSettingsDirty("ProjectSettings/DynamicsManager.asset");
+            }
+
+            string nameA = LayerMask.LayerToName(layerA);
+            string nameB = LayerMask.LayerToName(layerB);
+            if (string.IsNullOrEmpty(nameA)) nameA = layerA.ToString();
+            if (string.IsNullOrEmpty(nameB)) nameB = layerB.ToString();
+
+            return new
+            {
+                success = true,
+                message = $"Collision between '{nameA}' and '{nameB}' set to {(collide ? "enabled" : "disabled")} ({dimension}).",
+                data = new { layer_a = nameA, layer_b = nameB, collide, dimension }
+            };
+        }
+
+        private static void MarkSettingsDirty(string assetPath)
+        {
+            var assets = AssetDatabase.LoadAllAssetsAtPath(assetPath);
+            if (assets != null && assets.Length > 0)
+                EditorUtility.SetDirty(assets[0]);
+        }
+
+        private static int ResolveLayer(JToken token)
+        {
+            if (token.Type == JTokenType.Integer)
+            {
+                int idx = token.Value<int>();
+                return idx >= 0 && idx < 32 ? idx : -1;
+            }
+            string name = token.ToString();
+            if (int.TryParse(name, out int parsed))
+                return parsed >= 0 && parsed < 32 ? parsed : -1;
+            return LayerMask.NameToLayer(name);
+        }
+    }
+}