@alpsckr/unitycli 0.4.0

package/unitypkg/Editor/Tools/go/inspect.cs

@@ -0,0 +1,49 @@
+#if UNITY_EDITOR
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// go.inspect — 查看单个 GameObject 的摘要(id/name/path/active/tag/layer/transform/components/children)。
+    /// </summary>
+    public class GameObjectInspectTool : IUnityCliTool<GameObjectInspectTool.Request, GameObjectInspectTool.Result>
+    {
+        public sealed class Request
+        {
+            public string Target { get; set; }
+            public string Name { get; set; }
+            public string Path { get; set; }
+            public string Id { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public GameObjectDetail GameObject { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "go.inspect",
+            Summary = "Inspect one GameObject summary by name/path/id; use component.get for deep component fields.",
+            Description = "Inspect one GameObject by name, hierarchy path, or instance id. Returns transform, components and direct children; use object.get-data or component.get for deeper serialized data and keep go.find/scene.hierarchy for discovery.",
+            Group = "go",
+            DestructiveHint = false,
+            Target = "editor",
+            PlayModeSupport = "supported",
+            DefaultTimeoutMs = 30000,
+            MaxTimeoutMs = 600000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "Inspect by hierarchy path", Input = new Request { Target = "Player/CameraRig" } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var target = request.Target ?? request.Name ?? request.Path ?? request.Id;
+            var gameObject = GameObjectToolSupport.ResolveUniqueTarget(target, "GameObject inspect requires a target.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { GameObject = GameObjectToolSupport.BuildGameObjectDetail(gameObject) });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/go/look-at.cs

@@ -0,0 +1,76 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// go.look-at — 旋转 GameObject 使其 forward 指向另一个 GameObject。
+    /// </summary>
+    public class GameObjectLookAtTool : IUnityCliTool<GameObjectLookAtTool.Request, GameObjectLookAtTool.Result>
+    {
+        public sealed class Request
+        {
+            public string Target { get; set; }
+            public string LookAt { get; set; }
+            public string Destination { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public GameObjectDetail GameObject { get; set; }
+            public List<GameObjectPlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "go.look-at",
+            Summary = "Rotate a GameObject so its forward vector looks at another GameObject.",
+            Description = "Rotate a GameObject so its forward vector looks at another GameObject. Prefer hierarchy paths or instance ids for both target and lookAt after create/duplicate operations.",
+            Group = "go",
+            DestructiveHint = false,
+            SideEffects = new[] { "scene-modify", "undo-stack" },
+            Target = "editor",
+            PlayModeSupport = "session-affecting",
+            DefaultTimeoutMs = 30000,
+            MaxTimeoutMs = 600000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "Look at another object by hierarchy path", Input = new Request { Target = "CameraRig/MainCamera", LookAt = "Player/Avatar" } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            GameObjectToolSupport.EnsureEditorNotBusy("go.look-at");
+            if (string.IsNullOrEmpty(request.Target))
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_TARGET_NOT_FOUND", "GameObject look-at requires a target.", "Pass a GameObject name, hierarchy path or instance id.");
+            }
+            var gameObject = GameObjectToolSupport.ResolveUniqueTarget(request.Target, "GameObject look-at requires a target.");
+            var lookAtName = request.LookAt ?? request.Destination;
+            var lookAt = GameObjectToolSupport.ResolveUniqueTarget(lookAtName, "GameObject look-at requires a lookAt target. Use unitycli tools run go.look-at --input '{\"target\":\"CameraRig\",\"lookAt\":\"Player\"}'.");
+            var gameObjectId = gameObject.GetInstanceID();
+            var direction = lookAt.transform.position - gameObject.transform.position;
+            if (direction.sqrMagnitude <= Mathf.Epsilon)
+                throw new UnityCliBridge.BridgeCommandException("E_GO_LOOK_AT_DIRECTION_INVALID", "GameObject look-at target must not share the target position.", "Move one object before calling go.look-at.");
+            // 在 barrier 前冻结 LookAt 的不可变期望旋转，写入后只接受 fresh readback。
+            var expectedRotation = Quaternion.LookRotation(direction);
+            ctx.CommitEffect();
+            UnityCliSceneMutation.RecordObject(gameObject.transform, "go.look-at");
+            gameObject.transform.rotation = expectedRotation;
+            UnityCliSceneMutation.MarkSceneDirty(gameObject.scene);
+            var observed = EditorUtility.InstanceIDToObject(gameObjectId) as GameObject;
+            if (observed == null || Quaternion.Angle(observed.transform.rotation, expectedRotation) > 0.01f)
+                throw new UnityCliBridge.BridgeCommandException("E_GO_LOOK_AT_STATE_MISMATCH", "GameObject rotation did not match the requested look-at direction.", "Inspect the scene object and retry after the Editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                GameObject = GameObjectToolSupport.BuildGameObjectDetail(observed),
+                PlannedEffects = new List<GameObjectPlannedEffect> { new GameObjectPlannedEffect { Type = "go.look-at", Target = GameObjectToolSupport.HierarchyPath(observed) } }
+            });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/go/modify.cs

@@ -0,0 +1,156 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// go.modify — 修改一个或多个 GameObject 的名称/active/标签/层/绝对变换。
+    /// </summary>
+    public class GameObjectModifyTool : IUnityCliTool<GameObjectModifyTool.Request, GameObjectModifyTool.Result>
+    {
+        public sealed class Request
+        {
+            public string Target { get; set; }
+            public List<string> Targets { get; set; }
+            public string NewName { get; set; }
+            public string Parent { get; set; }
+            public bool? Active { get; set; }
+            public string TagValue { get; set; }
+            public string LayerValue { get; set; }
+            public double? X { get; set; }
+            public double? Y { get; set; }
+            public double? Z { get; set; }
+            public double? RotationX { get; set; }
+            public double? RotationY { get; set; }
+            public double? RotationZ { get; set; }
+            public double? ScaleX { get; set; }
+            public double? ScaleY { get; set; }
+            public double? ScaleZ { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public GameObjectDetail GameObject { get; set; }
+            public List<GameObjectDetail> GameObjects { get; set; }
+            public long ModifiedCount { get; set; }
+            public List<GameObjectPlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "go.modify",
+            Summary = "Modify one or more GameObjects' name, active state, tag, layer, absolute transform values, or parent.",
+            Description = "Modify one or more GameObjects' name, active state, tag, layer, absolute transform values, or parent. Pass target for one object or targets[] to apply the same mutation to multiple objects in one all-or-none call; every target must resolve uniquely before any scene object is changed.",
+            Group = "go",
+            DestructiveHint = false,
+            SideEffects = new[] { "scene-modify", "undo-stack" },
+            Target = "editor",
+            PlayModeSupport = "session-affecting",
+            DefaultTimeoutMs = 30000,
+            MaxTimeoutMs = 600000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "Move and deactivate by hierarchy path", Input = new Request { Target = "Player/Avatar", X = 1, Y = 2, Z = 3, Active = false } },
+                new ToolExample { Description = "Apply the same transform to multiple objects", Input = new Request { Targets = new List<string> { "Generated/A", "Generated/B" }, X = 0, Y = 1, Z = 0 } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            GameObjectToolSupport.EnsureEditorNotBusy("go.modify");
+            // 先完整校验,避免前半成功后半失败的部分写入
+            GameObjectToolSupport.ValidateMutationInputs(request.TagValue, request.LayerValue);
+            GameObjectToolSupport.ValidateTransformMutationValues(request.X, request.Y, request.Z, request.RotationX, request.RotationY, request.RotationZ, request.ScaleX, request.ScaleY, request.ScaleZ);
+            var plans = ResolveModifyTargets(request);
+            var parent = string.IsNullOrEmpty(request.Parent) ? null : GameObjectToolSupport.ResolveUniqueTarget(request.Parent, "Parent GameObject is required.");
+            var parentId = parent == null ? 0 : parent.GetInstanceID();
+            if (parent != null)
+            {
+                foreach (var plan in plans)
+                {
+                    var target = EditorUtility.InstanceIDToObject(plan.Id) as GameObject;
+                    if (target == null || parent.transform == target.transform || parent.transform.IsChildOf(target.transform))
+                        throw new UnityCliBridge.BridgeCommandException("E_GO_PARENT_CYCLE", "A GameObject cannot be parented to itself or one of its descendants.", "Choose a parent outside the target hierarchy.");
+                }
+            }
+            ctx.CommitEffect();
+            var undoGroup = UnityCliSceneMutation.BeginUndoGroup("go.modify");
+            try
+            {
+                var details = new List<GameObjectDetail>();
+                var effects = new List<GameObjectPlannedEffect>();
+                foreach (var plan in plans)
+                {
+                    var gameObject = EditorUtility.InstanceIDToObject(plan.Id) as GameObject;
+                    if (gameObject == null) throw new UnityCliBridge.BridgeCommandException("E_TARGET_NOT_FOUND", "GameObject disappeared before modification.", "Retry after the Editor is idle.");
+                    UnityCliSceneMutation.RecordObject(gameObject.transform, "go.modify");
+                    UnityCliSceneMutation.RecordObject(gameObject, "go.modify");
+                    GameObjectToolSupport.ApplyGameObjectMutations(gameObject, request.NewName, request.Active, request.TagValue, request.LayerValue,
+                        request.X, request.Y, request.Z, request.RotationX, request.RotationY, request.RotationZ, request.ScaleX, request.ScaleY, request.ScaleZ);
+                    if (parent != null) gameObject.transform.SetParent(parent.transform, true);
+                    UnityCliSceneMutation.MarkSceneDirty(gameObject.scene);
+                }
+                foreach (var plan in plans)
+                {
+                    var observed = EditorUtility.InstanceIDToObject(plan.Id) as GameObject;
+                    if (observed == null || !MatchesRequest(observed, request) || (request.Parent != null && (observed.transform.parent == null || observed.transform.parent.GetInstanceID() != parentId)))
+                        throw new UnityCliBridge.BridgeCommandException("E_GO_MODIFY_STATE_MISMATCH", "GameObject did not satisfy the requested mutation after write.", "Inspect the scene object and retry after the Editor is idle.");
+                    details.Add(GameObjectToolSupport.BuildGameObjectDetail(observed));
+                    effects.Add(new GameObjectPlannedEffect { Type = "go.modify", Target = GameObjectToolSupport.HierarchyPath(observed) });
+                }
+                if (details.Count == 1) return new System.Threading.Tasks.ValueTask<Result>(new Result { GameObject = details[0], ModifiedCount = 1, PlannedEffects = effects });
+                return new System.Threading.Tasks.ValueTask<Result>(new Result { GameObjects = details, ModifiedCount = details.Count, PlannedEffects = effects });
+            }
+            finally { UnityCliSceneMutation.EndUndoGroup(undoGroup); }
+        }
+
+        // go.modify 支持 targets[] 批量修改;先完整解析,避免部分写入
+        private sealed class ModifyPlan { public int Id { get; set; } }
+
+        private static bool MatchesRequest(GameObject observed, Request request)
+        {
+            if (request.NewName != null && observed.name != request.NewName) return false;
+            if (request.Active.HasValue && observed.activeSelf != request.Active.Value) return false;
+            if (request.TagValue != null && observed.tag != request.TagValue) return false;
+            if (request.LayerValue != null && observed.layer != GameObjectToolSupport.ParseLayer(request.LayerValue)) return false;
+            if (request.X.HasValue && !Mathf.Approximately(observed.transform.position.x, (float)request.X.Value)) return false;
+            if (request.Y.HasValue && !Mathf.Approximately(observed.transform.position.y, (float)request.Y.Value)) return false;
+            if (request.Z.HasValue && !Mathf.Approximately(observed.transform.position.z, (float)request.Z.Value)) return false;
+            if (request.RotationX.HasValue && !Mathf.Approximately(observed.transform.eulerAngles.x, (float)request.RotationX.Value)) return false;
+            if (request.RotationY.HasValue && !Mathf.Approximately(observed.transform.eulerAngles.y, (float)request.RotationY.Value)) return false;
+            if (request.RotationZ.HasValue && !Mathf.Approximately(observed.transform.eulerAngles.z, (float)request.RotationZ.Value)) return false;
+            if (request.ScaleX.HasValue && !Mathf.Approximately(observed.transform.localScale.x, (float)request.ScaleX.Value)) return false;
+            if (request.ScaleY.HasValue && !Mathf.Approximately(observed.transform.localScale.y, (float)request.ScaleY.Value)) return false;
+            return !request.ScaleZ.HasValue || Mathf.Approximately(observed.transform.localScale.z, (float)request.ScaleZ.Value);
+        }
+
+        private static List<ModifyPlan> ResolveModifyTargets(Request request)
+        {
+            if (request.Targets == null || request.Targets.Count == 0)
+            {
+                if (string.IsNullOrEmpty(request.Target))
+                {
+                    throw new UnityCliBridge.BridgeCommandException("E_TARGET_NOT_FOUND", "GameObject modify requires target or targets[].", "Pass target for one object or targets as a non-empty string array.");
+                }
+                var target = GameObjectToolSupport.ResolveUniqueTarget(request.Target, "GameObject modify requires target or targets[].");
+                return new List<ModifyPlan> { new ModifyPlan { Id = target.GetInstanceID() } };
+            }
+            var targets = new List<ModifyPlan>();
+            var seen = new HashSet<int>();
+            foreach (var targetName in request.Targets)
+            {
+                var gameObject = GameObjectToolSupport.ResolveUniqueTarget(targetName, "GameObject modify targets[] contains an empty target.");
+                if (seen.Add(gameObject.GetInstanceID())) targets.Add(new ModifyPlan { Id = gameObject.GetInstanceID() });
+            }
+            if (targets.Count == 0)
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_TARGET_NOT_FOUND", "GameObject modify targets[] must contain at least one target.", "Pass target for one object or targets as a non-empty string array.");
+            }
+            return targets;
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/go/move-relative.cs

@@ -0,0 +1,74 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// go.move-relative — 按 XYZ 偏移移动 GameObject,不替换绝对变换。
+    /// </summary>
+    public class GameObjectMoveRelativeTool : IUnityCliTool<GameObjectMoveRelativeTool.Request, GameObjectMoveRelativeTool.Result>
+    {
+        public sealed class Request
+        {
+            public string Target { get; set; }
+            public double? OffsetX { get; set; }
+            public double? OffsetY { get; set; }
+            public double? OffsetZ { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public GameObjectDetail GameObject { get; set; }
+            public List<GameObjectPlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "go.move-relative",
+            Summary = "Move a GameObject by a relative XYZ offset without replacing its absolute transform.",
+            Description = "Move a GameObject by a relative XYZ offset without replacing its absolute transform. Use go.modify when you need absolute position; prefer hierarchy paths or instance ids after create/duplicate operations.",
+            Group = "go",
+            DestructiveHint = false,
+            SideEffects = new[] { "scene-modify", "undo-stack" },
+            Target = "editor",
+            PlayModeSupport = "session-affecting",
+            DefaultTimeoutMs = 30000,
+            MaxTimeoutMs = 600000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "Move up by hierarchy path", Input = new Request { Target = "Player/Avatar", OffsetX = 0, OffsetY = 2, OffsetZ = 0 } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            GameObjectToolSupport.EnsureEditorNotBusy("go.move-relative");
+            if (string.IsNullOrEmpty(request.Target))
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_TARGET_NOT_FOUND", "GameObject move-relative requires a target.", "Pass a GameObject name, hierarchy path or instance id.");
+            }
+            var gameObject = GameObjectToolSupport.ResolveUniqueTarget(request.Target, "GameObject move-relative requires a target.");
+            GameObjectToolSupport.ValidateTransformMutationValues(request.OffsetX, request.OffsetY, request.OffsetZ);
+            var gameObjectId = gameObject.GetInstanceID();
+            var offset = new Vector3((float)(request.OffsetX ?? 0), (float)(request.OffsetY ?? 0), (float)(request.OffsetZ ?? 0));
+            // 以写入前位置加请求偏移冻结期望值，不能用写后旧引用自证。
+            var expectedPosition = gameObject.transform.position + offset;
+            ctx.CommitEffect();
+            UnityCliSceneMutation.RecordObject(gameObject.transform, "go.move-relative");
+            gameObject.transform.position = expectedPosition;
+            UnityCliSceneMutation.MarkSceneDirty(gameObject.scene);
+            var observed = EditorUtility.InstanceIDToObject(gameObjectId) as GameObject;
+            if (observed == null || !Mathf.Approximately(observed.transform.position.x, expectedPosition.x) || !Mathf.Approximately(observed.transform.position.y, expectedPosition.y) || !Mathf.Approximately(observed.transform.position.z, expectedPosition.z))
+                throw new UnityCliBridge.BridgeCommandException("E_GO_MOVE_RELATIVE_STATE_MISMATCH", "GameObject move was not observed after write.", "Inspect the scene object and retry after the Editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                GameObject = GameObjectToolSupport.BuildGameObjectDetail(observed),
+                PlannedEffects = new List<GameObjectPlannedEffect> { new GameObjectPlannedEffect { Type = "go.move-relative", Target = GameObjectToolSupport.HierarchyPath(gameObject) } }
+            });
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/go/set-parent.cs

@@ -0,0 +1,84 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// go.set-parent — 将 GameObject 重新父级化到另一个 GameObject 或脱离到场景根。支持 dryRun。
+    /// </summary>
+    public class GameObjectSetParentTool : IUnityCliTool<GameObjectSetParentTool.Request, GameObjectSetParentTool.Result>
+    {
+        public sealed class Request
+        {
+            public string Target { get; set; }
+            public string Parent { get; set; }
+            public bool? WorldPositionStays { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public bool? DryRun { get; set; }
+            public List<GameObjectPlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "go.set-parent",
+            Summary = "Reparent a GameObject under another GameObject or detach it to the scene root.",
+            Description = "Reparent a GameObject under another GameObject or detach it to the scene root. Prefer hierarchy paths or instance ids for target and parent; plain names can be ambiguous after duplicate/create operations. Use --dry-run first for hierarchy work; worldPositionStays defaults to true.",
+            Group = "go",
+            DestructiveHint = false,
+            SupportsDryRun = true,
+            SideEffects = new[] { "scene-modify", "undo-stack", "hierarchy-reparent" },
+            Target = "editor",
+            PlayModeSupport = "session-affecting",
+            DefaultTimeoutMs = 30000,
+            MaxTimeoutMs = 600000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "Dry-run reparent by hierarchy path", Input = new Request { Target = "Player/Sword", Parent = "Player/RightHand", WorldPositionStays = true }, Execution = new ToolExampleExecution { DryRun = true } },
+                new ToolExample { Description = "Detach to root by hierarchy path", Input = new Request { Target = "Player/Sword" } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            GameObjectToolSupport.EnsureEditorNotBusy("go.set-parent");
+            if (string.IsNullOrEmpty(request.Target))
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_TARGET_NOT_FOUND", "go.set-parent requires a target.", "Pass a GameObject name, hierarchy path or instance id.");
+            }
+            var gameObject = GameObjectToolSupport.ResolveUniqueTarget(request.Target, "go.set-parent requires a target.");
+            var parentName = request.Parent;
+            var worldPositionStays = request.WorldPositionStays ?? true;
+            var newParent = string.IsNullOrEmpty(parentName) ? null : GameObjectToolSupport.ResolveUniqueTarget(parentName, "Parent GameObject is required.").transform;
+            if (newParent == gameObject.transform || (newParent != null && newParent.IsChildOf(gameObject.transform)))
+                throw new UnityCliBridge.BridgeCommandException("E_GO_PARENT_CYCLE", "A GameObject cannot be parented to itself or one of its descendants.", "Choose a parent outside the target hierarchy.");
+            var targetId = gameObject.GetInstanceID();
+            var parentId = newParent == null ? 0 : newParent.GetInstanceID();
+            if (ctx.DryRun)
+            {
+                return new System.Threading.Tasks.ValueTask<Result>(new Result
+                {
+                    DryRun = true,
+                    PlannedEffects = new List<GameObjectPlannedEffect> { new GameObjectPlannedEffect { Type = "go.set-parent", Parent = parentName ?? "<root>" } }
+                });
+            }
+            ctx.CommitEffect();
+            UnityCliSceneMutation.SetParent(gameObject.transform, newParent, "go.set-parent", worldPositionStays);
+            UnityCliSceneMutation.MarkSceneDirty(gameObject.scene);
+            var observed = EditorUtility.InstanceIDToObject(targetId) as GameObject;
+            var observedParent = parentId == 0 ? null : EditorUtility.InstanceIDToObject(parentId) as Transform;
+            if (observed == null || observed.transform.parent != observedParent)
+                throw new UnityCliBridge.BridgeCommandException("E_GO_SET_PARENT_STATE_MISMATCH", "GameObject hierarchy did not match the requested parent after write.", "Inspect the hierarchy and retry after the Editor is idle.");
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                PlannedEffects = new List<GameObjectPlannedEffect> { new GameObjectPlannedEffect { Type = "go.set-parent" } }
+            });
+        }
+    }
+}
+#endif