@mflrevan/ucp 0.6.0 → 0.6.2

package/bridge/com.ucp.bridge/Editor/Controllers/RecordingController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7b8f17a452e84a2eb71a124ba55cf321
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData:
+  assetBundleName:
+  assetBundleVariant:

package/bridge/com.ucp.bridge/Editor/Controllers/SceneController.cs

@@ -168,19 +168,41 @@ namespace UCP.Bridge
             sceneView.Repaint();
             SceneView.RepaintAll();
 
+            ResolveSceneViewCamera(sceneView, out var cameraPosition, out var cameraRotation);
+
             return new Dictionary<string, object>
             {
                 ["status"] = "ok",
                 ["instanceId"] = instanceId,
                 ["name"] = target.name,
                 ["pivot"] = VectorToList(sceneView.pivot),
-                ["cameraPosition"] = VectorToList(sceneView.camera.transform.position),
-                ["cameraRotationEuler"] = VectorToList(sceneView.camera.transform.rotation.eulerAngles),
+                ["cameraPosition"] = VectorToList(cameraPosition),
+                ["cameraRotationEuler"] = VectorToList(cameraRotation.eulerAngles),
                 ["size"] = sceneView.size,
                 ["axis"] = axis.HasValue ? VectorToList(axis.Value.normalized) : null
             };
         }
 
+        /// <summary>
+        /// Derive the Scene view camera pose from the authoritative view state
+        /// (<c>pivot</c>/<c>rotation</c>/<c>cameraDistance</c>) rather than reading
+        /// <c>sceneView.camera.transform</c>.
+        ///
+        /// <c>LookAtDirect</c> updates the view state immediately, but the camera transform is only
+        /// synced when the Scene view actually repaints. <c>Repaint()</c> merely queues that, so in
+        /// batch mode - and for any caller reading the response in the same frame as the focus -
+        /// the camera transform still holds the *previous* pose and the reported values were simply
+        /// wrong.
+        /// </summary>
+        private static void ResolveSceneViewCamera(
+            SceneView sceneView,
+            out Vector3 position,
+            out Quaternion rotation)
+        {
+            rotation = sceneView.rotation;
+            position = sceneView.pivot - (rotation * Vector3.forward) * sceneView.cameraDistance;
+        }
+
         private static Vector3? TryReadAxis(Dictionary<string, object> parameters)
         {
             if (parameters == null || !parameters.TryGetValue("axis", out var axisObj) || axisObj == null)

package/bridge/com.ucp.bridge/Editor/Controllers/ScriptController.cs

@@ -12,29 +12,35 @@ namespace UCP.Bridge
             router.Register("exec/run", HandleRun);
         }
 
-        private static List<IUCPScript> DiscoverScripts()
+        /// <summary>
+        /// Implementing types, cached for the lifetime of the app domain. The scan itself is the
+        /// expensive part -- `GetTypes()` over every loaded assembly -- and its result cannot go
+        /// stale without a domain reload, which resets this static anyway.
+        /// </summary>
+        private static Type[] s_scriptTypes;
+
+        private static Type[] DiscoverScriptTypes()
         {
-            var scripts = new List<IUCPScript>();
+            if (s_scriptTypes != null) return s_scriptTypes;
+
             var interfaceType = typeof(IUCPScript);
+            var bridgeAssemblyName = interfaceType.Assembly.GetName().Name;
+            var types = new List<Type>();
 
             foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
             {
+                // A type can only implement IUCPScript if its assembly references the one that
+                // declares it. Checking cheap reference metadata first avoids materialising the
+                // full type list of every framework and Unity assembly in the domain.
+                if (assembly != interfaceType.Assembly && !ReferencesAssembly(assembly, bridgeAssemblyName))
+                    continue;
+
                 try
                 {
                     foreach (var type in assembly.GetTypes())
                     {
                         if (interfaceType.IsAssignableFrom(type) && !type.IsAbstract && !type.IsInterface)
-                        {
-                            try
-                            {
-                                var instance = (IUCPScript)Activator.CreateInstance(type);
-                                scripts.Add(instance);
-                            }
-                            catch (Exception ex)
-                            {
-                                Debug.LogWarning($"[UCP] Failed to instantiate script {type.Name}: {ex.Message}");
-                            }
-                        }
+                            types.Add(type);
                     }
                 }
                 catch (System.Reflection.ReflectionTypeLoadException)
@@ -43,9 +49,71 @@ namespace UCP.Bridge
                 }
             }
 
+            s_scriptTypes = types.ToArray();
+            return s_scriptTypes;
+        }
+
+        private static bool ReferencesAssembly(System.Reflection.Assembly assembly, string name)
+        {
+            try
+            {
+                foreach (var reference in assembly.GetReferencedAssemblies())
+                {
+                    if (string.Equals(reference.Name, name, StringComparison.Ordinal)) return true;
+                }
+            }
+            catch
+            {
+                // Dynamic assemblies can refuse to report references; treat them as non-matching.
+            }
+
+            return false;
+        }
+
+        private static IUCPScript Instantiate(Type type)
+        {
+            try
+            {
+                return (IUCPScript)Activator.CreateInstance(type);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"[UCP] Failed to instantiate script {type.Name}: {ex.Message}");
+                return null;
+            }
+        }
+
+        private static List<IUCPScript> DiscoverScripts()
+        {
+            var scripts = new List<IUCPScript>();
+            foreach (var type in DiscoverScriptTypes())
+            {
+                var instance = Instantiate(type);
+                if (instance != null) scripts.Add(instance);
+            }
+
             return scripts;
         }
 
+        /// <summary>
+        /// Resolve one script by name, stopping at the first match.
+        /// `Name` is an instance member, so candidates must be constructed to be identified --
+        /// but running *every* script's constructor to invoke one of them is a side effect nobody
+        /// asked for, so stop as soon as the target is found.
+        /// </summary>
+        private static IUCPScript FindScript(string name)
+        {
+            foreach (var type in DiscoverScriptTypes())
+            {
+                var instance = Instantiate(type);
+                if (instance == null) continue;
+                if (string.Equals(instance.Name, name, StringComparison.OrdinalIgnoreCase))
+                    return instance;
+            }
+
+            return null;
+        }
+
         private static object HandleList(string paramsJson)
         {
             var scripts = DiscoverScripts();
@@ -78,16 +146,7 @@ namespace UCP.Bridge
             if (p.TryGetValue("params", out var paramsObj) && paramsObj != null)
                 scriptParams = MiniJson.Serialize(paramsObj);
 
-            var scripts = DiscoverScripts();
-            IUCPScript target = null;
-            foreach (var s in scripts)
-            {
-                if (string.Equals(s.Name, name, StringComparison.OrdinalIgnoreCase))
-                {
-                    target = s;
-                    break;
-                }
-            }
+            var target = FindScript(name);
 
             if (target == null)
                 throw new ArgumentException($"Script not found: {name}. Use exec/list to see available scripts.");

package/bridge/com.ucp.bridge/Editor/Controllers/TestRunnerController.cs

@@ -54,7 +54,10 @@ namespace UCP.Bridge
 
             if (!string.IsNullOrEmpty(filter))
             {
-                executionSettings.filters[0].testNames = new[] { filter };
+                // groupNames is regex-matched against each test's full name, so a bare class or
+                // method name selects what a caller expects. testNames requires an exact
+                // fully-qualified match, which silently selected nothing for "ControllerSmokeTests".
+                executionSettings.filters[0].groupNames = new[] { filter };
             }
 
             var shouldWaitForPlayModeExit =
@@ -208,6 +211,12 @@ namespace UCP.Bridge
                     return;
                 }
 
+                // A filter that matches nothing still yields a root suite -- childless, and named
+                // after the project. Counting it as a leaf reported "1 passed" for a run that
+                // executed no tests, so a typo'd filter looked like a green suite.
+                if (result.Test != null && result.Test.IsSuite)
+                    return;
+
                 string status;
                 switch (result.TestStatus)
                 {