Esempio n. 1
0
        private void Initialize(UnityEngine.Object target)
        {
            data = new RefactorData();
            GameObject gameObject = target as GameObject;

            if (target is Component)
            {
                gameObject = (target as Component).gameObject;
            }
            if (gameObject != null)
            {
                var scripts = gameObject.GetComponentsInChildren <MonoBehaviour>(true);
                Func <object, bool> scriptValidation = (obj) => {
                    MemberData member = obj as MemberData;
                    if (member != null)
                    {
                        FindMissingMember(member, false);
                    }
                    return(false);
                };
                Array.ForEach(scripts, script => {
                    data.missingTarget.Add(script);
                    AnalizerUtility.AnalizeObject(script, scriptValidation);
                });
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Get the graph singleton instance
        /// </summary>
        /// <param name="graphSingleton"></param>
        /// <returns></returns>
        internal static uNodeRuntime GetRuntimeGraph(uNodeComponentSingleton graphSingleton)
        {
            uNodeRuntime instance;

            if (!graphSingletons.TryGetValue(graphSingleton, out instance) || instance == null)
            {
                var objs = GameObject.FindObjectsOfType <uNodeRuntime>();
                instance = objs.FirstOrDefault(g => g.GraphName == graphSingleton.GraphName);
                if (instance == null)
                {
                    GameObject mainObject = new GameObject($"[Singleton:{graphSingleton.GraphName}]");
                    if (graphSingleton.IsPersistence)
                    {
                        GameObject.DontDestroyOnLoad(mainObject);
                    }
                    uNodeRoot    graph = UnityEngine.Object.Instantiate(graphSingleton);
                    uNodeRuntime main  = mainObject.AddComponent <uNodeRuntime>();
                    main.originalGraph = graphSingleton;
                    main.Name          = graphSingleton.GraphName;           //This will ensure the uid is valid
                    main.Variables     = graph.Variables;
                    main.RootObject    = graph.RootObject;
                    main.RootObject.transform.SetParent(mainObject.transform);
                    AnalizerUtility.RetargetNodeOwner(graph, main, main.RootObject.GetComponentsInChildren <MonoBehaviour>(true));
                    main.Refresh();
                    UnityEngine.Object.Destroy(graph.gameObject);
                    instance = main;
                    graphSingletons[instance] = instance;
                }
            }
            return(instance);
        }
Esempio n. 3
0
        private void Initialize()
        {
            data = new RefactorData();
            var graphPrefabs = uNodeEditorUtility.FindPrefabsOfType <uNodeRoot>();

            foreach (var prefab in graphPrefabs)
            {
                var gameObject = prefab;
                if (GraphUtility.HasTempGraphObject(prefab))
                {
                    gameObject = GraphUtility.GetTempGraphObject(prefab);
                }
                var scripts = gameObject.GetComponentsInChildren <MonoBehaviour>(true);
                Func <object, bool> scriptValidation = (obj) => {
                    MemberData member = obj as MemberData;
                    if (member != null)
                    {
                        FindMissingMember(member, false);
                    }
                    return(false);
                };
                Array.ForEach(scripts, script => {
                    data.missingTarget.Add(script);
                    AnalizerUtility.AnalizeObject(script, scriptValidation);
                });
            }
        }
Esempio n. 4
0
 /// <summary>
 /// True if instance variable from node has used in flow nodes.
 /// </summary>
 /// <param name="from"></param>
 /// <param name="field"></param>
 /// <param name="index"></param>
 /// <param name="flows"></param>
 /// <returns></returns>
 public static bool NeedInstanceVariable(Node from, FieldInfo field, int index, IList <Node> flows)
 {
     if (from && flows != null && flows.Count > 0)
     {
         var allConnection = GetAllNode(from.transform.parent);
         var allFlows      = new HashSet <NodeComponent>();
         foreach (var flow in flows)
         {
             if (flow == null)
             {
                 continue;
             }
             FindAllNodeConnection(flow, ref allFlows);
         }
         bool check = false;
         Func <object, bool> validation = null;
         validation = delegate(object obj) {
             if (obj is MemberData)
             {
                 MemberData member = obj as MemberData;
                 if (member.isAssigned)
                 {
                     Node n = member.GetTargetNode();
                     if (n)
                     {
                         int tes;
                         if (member.targetType == MemberData.TargetType.NodeFieldElement && n == from &&
                             int.TryParse(member.startName.Split('#')[1], out tes) && tes == index &&
                             member.startName.Split('#')[0] == field.Name)
                         {
                             check = true;
                         }
                         else if (member.targetType == MemberData.TargetType.ValueNode)
                         {
                             AnalizerUtility.AnalizeObject(n, validation);
                         }
                     }
                 }
             }
             return(check);
         };
         foreach (Node node in allConnection)
         {
             if (node == null || !isInUngrouped && IsGroupedNode(from) /*&& allFlows.Contains(node)*/)
             {
                 continue;
             }
             AnalizerUtility.AnalizeObject(node, validation);
             if (check)
             {
                 var nodes = GetFlowConnectedTo(node);
                 if (nodes.Count > 0)
                 {
                     return(nodes.Any(n => !allFlows.Contains(n)));
                 }
             }
         }
     }
     return(false);
 }
Esempio n. 5
0
        /// <summary>
        /// Save the runtime graph to a prefab
        /// </summary>
        /// <param name="runtimeGraph"></param>
        /// <param name="graphAsset"></param>
        public static void SaveRuntimeGraph(uNodeRuntime runtimeGraph)
        {
            if (!Application.isPlaying)
            {
                throw new System.Exception("Saving runtime graph can only be done in playmode");
            }
            if (runtimeGraph.originalGraph == null)
            {
                throw new System.Exception("Cannot save runtime graph because the original graph was null / missing");
            }
            var graph = runtimeGraph.originalGraph;

            if (!EditorUtility.IsPersistent(graph))
            {
                throw new System.Exception("Cannot save graph to unpersistent asset");
            }
            var prefabContent = PrefabUtility.LoadPrefabContents(AssetDatabase.GetAssetPath(graph));
            var originalGraph = uNodeHelper.GetGraphComponent(prefabContent, graph.GraphName);

            if (originalGraph != null)
            {
                if (runtimeGraph.RootObject != null)
                {
                    //Duplicate graph data
                    var tempRoot = Object.Instantiate(runtimeGraph.RootObject);
                    tempRoot.name = "Root";
                    //Move graph data to original graph
                    tempRoot.transform.SetParent(originalGraph.transform);
                    //Retarget graph data owner
                    AnalizerUtility.RetargetNodeOwner(runtimeGraph, originalGraph, tempRoot.GetComponentsInChildren <MonoBehaviour>(true));
                    if (originalGraph.RootObject != null)
                    {
                        //Destroy old graph data
                        Object.DestroyImmediate(originalGraph.RootObject);
                    }
                    //Update graph data to new
                    originalGraph.RootObject = tempRoot;
                    //Save the graph to prefab
                    uNodeEditorUtility.SavePrefabAsset(prefabContent, graph);
                    //GraphUtility.DestroyTempGraphObject(originalGraph.gameObject);

                    //This will update the original graph
                    GraphUtility.DestroyTempGraphObject(graph.gameObject);
                    //Refresh uNode Editor window
                    uNodeEditor.window?.Refresh();
                }
            }
            else
            {
                Debug.LogError("Cannot save instanced graph because the cannot find original graph with id:" + graph.GraphName);
            }
            PrefabUtility.UnloadPrefabContents(prefabContent);
        }
Esempio n. 6
0
        public static HashSet <NodeComponent> GetConnections(NodeComponent node)
        {
            HashSet <NodeComponent> allNodes;

            if (generatorData.nodeConnectionsMap.TryGetValue(node, out allNodes))
            {
                return(allNodes);
            }
            allNodes = new HashSet <NodeComponent>();
            if (node is StateNode)
            {
                StateNode         eventNode = node as StateNode;
                TransitionEvent[] TE        = eventNode.GetTransitions();
                foreach (TransitionEvent transition in TE)
                {
                    var tNode = transition.GetTargetNode();
                    if (tNode != null)
                    {
                        allNodes.Add(tNode);
                    }
                }
            }
            else if (node is BaseEventNode)
            {
                BaseEventNode stateEvent = node as BaseEventNode;
                foreach (var member in stateEvent.GetFlows())
                {
                    var tNode = member.GetTargetNode();
                    if (tNode != null)
                    {
                        allNodes.Add(tNode);
                    }
                }
            }
            Func <object, bool> validation = delegate(object obj) {
                if (obj is MemberData)
                {
                    MemberData member = obj as MemberData;
                    if (member != null && member.IsTargetingPinOrNode)
                    {
                        allNodes.Add(member.GetTargetNode());
                    }
                }
                return(false);
            };

            AnalizerUtility.AnalizeObject(node, validation);
            generatorData.nodeConnectionsMap[node] = allNodes;
            return(allNodes);
        }
Esempio n. 7
0
 void OnGUI()
 {
     scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
     for (int i = 0; i < data.missingMembers.Count; i++)
     {
         var mMember = data.missingMembers[i];
         EditorGUILayout.LabelField("Type: " + mMember.type.PrettyName(true));
         EditorGUILayout.BeginHorizontal();
         EditorGUILayout.PrefixLabel(mMember.name);
         mMember.value = EditorGUILayout.TextField(mMember.value);
         EditorGUILayout.EndHorizontal();
     }
     EditorGUILayout.EndScrollView();
     GUILayout.FlexibleSpace();
     if (GUILayout.Button("Start Refactor"))
     {
         bool flag = false;
         Func <object, bool> scriptValidation = (obj) => {
             MemberData member = obj as MemberData;
             if (member != null)
             {
                 flag = FindMissingMember(member, true) || flag;
             }
             return(false);
         };
         foreach (var target in data.missingTarget)
         {
             AnalizerUtility.AnalizeObject(target, scriptValidation);
             if (flag)
             {
                 flag = false;
                 uNodeGUIUtility.GUIChanged(target);
                 if (EditorUtility.IsPersistent(target))
                 {
                     uNodeEditorUtility.MarkDirty(target);
                 }
             }
         }
         uNodeEditor.ClearGraphCache();
         uNodeEditor.window?.Refresh(true);
         Close();
     }
 }
Esempio n. 8
0
        public static void RetargetValueNode(Node source, Node destination)
        {
            List <uNodeComponent> nodes = new List <uNodeComponent>();

            foreach (Transform t in source.transform.parent)
            {
                var comp = t.GetComponent <uNodeComponent>();
                if (comp != null)
                {
                    if (comp is StateNode)
                    {
                        var state       = comp as StateNode;
                        var transitions = state.GetTransitions();
                        foreach (var tr in transitions)
                        {
                            nodes.Add(tr);
                        }
                    }
                    nodes.Add(comp);
                }
            }
            Func <object, bool> validation = delegate(object o) {
                if (o is MemberData)
                {
                    MemberData member = o as MemberData;
                    if (member.targetType == MemberData.TargetType.ValueNode)
                    {
                        Node n = member.GetTargetNode();
                        if (n != null && n == source)
                        {
                            member.RefactorUnityObject(new Object[] { source }, new Object[] { destination });
                            //return true;
                        }
                    }
                }
                return(false);
            };

            foreach (var n in nodes)
            {
                AnalizerUtility.AnalizeObject(n, validation);
            }
        }
Esempio n. 9
0
 private static void ConnectNode(NodeComponent node)
 {
     if (node != null && !generatorData.connectedNode.Contains(node))
     {
         generatorData.connectedNode.Add(node);
         var nodes = GetConnections(node);
         if (nodes != null)
         {
             foreach (NodeComponent n in nodes)
             {
                 if (n)
                 {
                     ConnectNode(n);
                 }
             }
         }
         if (node is ISuperNode)
         {
             ISuperNode superNode = node as ISuperNode;
             foreach (var n in superNode.nestedFlowNodes)
             {
                 if (n != null)
                 {
                     ConnectNode(n);
                 }
             }
         }
         Func <object, bool> validation = delegate(object obj) {
             if (obj is MemberData)
             {
                 MemberData member = obj as MemberData;
                 if (member.IsTargetingPinOrNode)
                 {
                     ConnectNode(member.GetTargetNode());
                 }
             }
             return(false);
         };
         AnalizerUtility.AnalizeObject(node, validation);
     }
 }
Esempio n. 10
0
        /// <summary>
        /// Get flow nodes from node.
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        public static HashSet <NodeComponent> GetFlowConnection(NodeComponent node)
        {
            HashSet <NodeComponent> allNodes;

            if (generatorData.flowNodeConnectionsMap.TryGetValue(node, out allNodes))
            {
                return(allNodes);
            }
            allNodes = new HashSet <NodeComponent>();
            if (node is StateNode)
            {
                StateNode         eventNode = node as StateNode;
                TransitionEvent[] TE        = eventNode.GetTransitions();
                foreach (TransitionEvent transition in TE)
                {
                    if (transition.GetTargetNode() != null && !allNodes.Contains(transition.GetTargetNode()))
                    {
                        allNodes.Add(transition.GetTargetNode());
                    }
                }
            }
            Func <object, bool> validation = delegate(object obj) {
                if (obj is MemberData)
                {
                    MemberData member = obj as MemberData;
                    if (member != null && member.isAssigned &&
                        (member.targetType == MemberData.TargetType.FlowNode ||
                         member.targetType == MemberData.TargetType.FlowInput) &&
                        !allNodes.Contains(member.GetTargetNode()))
                    {
                        allNodes.Add(member.GetTargetNode());
                    }
                }
                return(false);
            };

            AnalizerUtility.AnalizeObject(node, validation);
            generatorData.flowNodeConnectionsMap[node] = allNodes;
            return(allNodes);
        }
Esempio n. 11
0
        public override uNodeRoot Convert(uNodeRoot graph)
        {
            var cls        = Object.Instantiate(graph);
            var gameObject = new GameObject("Converted Graph");
            var result     = gameObject.AddComponent <uNodeClass>();

            result.Name = cls.Name;
            result.Variables.Clear();
            foreach (var v in cls.Variables)
            {
                result.Variables.Add(new VariableData(v));
            }
            result.inheritFrom = new MemberData(cls.GetInheritType());
            result.RootObject  = cls.RootObject;
            if (result.RootObject != null)
            {
                result.RootObject.transform.SetParent(gameObject.transform);
                AnalizerUtility.RetargetNodeOwner(cls, result, result.RootObject.GetComponentsInChildren <MonoBehaviour>(true));
            }
            Object.DestroyImmediate(cls.gameObject);
            result.Refresh();
            return(result);
        }
Esempio n. 12
0
        public override uNodeRoot Convert(uNodeRoot graph)
        {
            var cls        = Object.Instantiate(graph);
            var gameObject = new GameObject("Converted Graph");
            var result     = gameObject.AddComponent <uNodeRuntime>();

            result.Name = cls.Name;
            result.Variables.Clear();
            foreach (var v in cls.Variables)
            {
                result.Variables.Add(new VariableData(v));
            }
            result.RootObject = cls.RootObject;
            if (result.RootObject != null)
            {
                result.RootObject.transform.SetParent(gameObject.transform);
                AnalizerUtility.RetargetNodeOwner(cls, result, result.RootObject.GetComponentsInChildren <MonoBehaviour>(true));
            }
            Object.DestroyImmediate(cls.gameObject);
            result.Refresh();
            ValidateGraph(result, supportAttribute: false, supportGeneric: false, supportModifier: false, supportNativeType: false, supportConstructor: false);
            return(result);
        }
Esempio n. 13
0
        public void PasteNode(Vector3 position)
        {
            if (nodeToCopy == null || nodeToCopy.Count == 0)
            {
                return;
            }
            if (uNodeEditorUtility.IsPrefab(editorData.graph.gameObject))
            {
                throw new Exception("Editing graph prefab dirrectly is not supported.");
            }
            uNodeEditorUtility.RegisterUndo(editorData.graph, "Paste Node");
            uNodeRoot UNR       = editorData.graph;
            float     progress  = 0;
            int       loopIndex = 0;

            if (nodeToCopy.Count > 5)
            {
                EditorUtility.DisplayProgressBar("Loading", "", progress);
            }
            Vector2 center       = Vector2.zero;
            int     centerLength = 0;
            Dictionary <uNodeComponent, uNodeComponent> CopyedObjectMap = new Dictionary <uNodeComponent, uNodeComponent>(EqualityComparer <uNodeComponent> .Default);

            foreach (uNodeComponent comp in nodeToCopy)
            {
                if (comp == null || comp is EventNode && editorData.selectedGroup != null)
                {
                    continue;
                }
                Node node = comp as Node;
                if (!CopyedObjectMap.ContainsKey(comp))
                {
                    uNodeComponent com = Object.Instantiate(comp);
                    com.gameObject.name = com.gameObject.name.Replace("(Clone)", "");
                    if (editorData.selectedGroup == null)
                    {
                        if (editorData.selectedRoot)
                        {
                            com.transform.parent = editorData.selectedRoot.transform;
                        }
                        else
                        {
                            com.transform.parent = NodeEditorUtility.GetNodeRoot(UNR).transform;
                        }
                    }
                    else
                    {
                        com.transform.parent = editorData.selectedGroup.transform;
                    }
                    int    index = 0;
                    string nm    = com.gameObject.name.TrimEnd(numberChar);
                    while (true)
                    {
                        bool   flag  = false;
                        string gName = com.gameObject.name;
                        foreach (Transform t in com.transform.parent)
                        {
                            if (t != com.transform)
                            {
                                if (t.gameObject.name.Equals(gName))
                                {
                                    flag = true;
                                    break;
                                }
                            }
                        }
                        if (flag)
                        {
                            com.gameObject.name = nm + index.ToString();
                            index++;
                            continue;
                        }
                        break;
                    }
                    CopyedObjectMap.Add(comp, com);
                    if (comp is IMacro || comp is ISuperNode)
                    {
                        var fields = EditorReflectionUtility.GetFields(comp.GetType());
                        foreach (var field in fields)
                        {
                            if (field.FieldType == typeof(List <Nodes.MacroPortNode>))
                            {
                                var value = field.GetValueOptimized(comp) as List <Nodes.MacroPortNode>;
                                if (value != null)
                                {
                                    var sourceValue = field.GetValueOptimized(com) as List <Nodes.MacroPortNode>;
                                    for (int i = 0; i < value.Count; i++)
                                    {
                                        if (value[i] == null)
                                        {
                                            continue;
                                        }
                                        CopyedObjectMap.Add(value[i], sourceValue[i]);
                                    }
                                }
                            }
                        }
                    }
                }
                if (node != null)
                {
                    center.x += node.editorRect.x;
                    center.y += node.editorRect.y;
                    centerLength++;
                }
                else
                {
                    BaseEventNode met = comp as BaseEventNode;
                    if (met != null)
                    {
                        center.x += met.editorRect.x;
                        center.y += met.editorRect.y;
                        centerLength++;
                    }
                }
                loopIndex++;
                progress = (float)loopIndex / (float)nodeToCopy.Count;
                if (nodeToCopy.Count > 5)
                {
                    EditorUtility.DisplayProgressBar("Loading", "", progress);
                }
            }
            progress = 0;
            center  /= centerLength;
            HashSet <uNodeComponent> needReflectedComponent = new HashSet <uNodeComponent>();
            uNodeRoot compEvent = null;

            foreach (uNodeComponent com in nodeToCopy)
            {
                uNodeComponent comp = null;
                if (CopyedObjectMap.ContainsKey(com))
                {
                    comp = CopyedObjectMap[com];
                    if (comp == null)
                    {
                        loopIndex++;
                        progress = (float)loopIndex / (float)nodeToCopy.Count;
                        if (nodeToCopy.Count > 5)
                        {
                            EditorUtility.DisplayProgressBar("Loading", "", progress);
                        }
                        continue;
                    }
                    if (comp as Node)
                    {
                        Node node = comp as Node;
                        Func <object, bool> validation = delegate(object o) {
                            if (o is MemberData)
                            {
                                MemberData member = o as MemberData;
                                if (member.IsTargetingPinOrNode)
                                {
                                    NodeComponent n = member.GetInstance() as NodeComponent;
                                    if (n && n is uNodeComponent)
                                    {
                                        if (CopyedObjectMap.ContainsKey(n))
                                        {
                                            member.instance = CopyedObjectMap[n] as NodeComponent;
                                            n.owner         = UNR;
                                            return(true);
                                        }
                                        else if (n.owner != UNR || n.transform.parent != node.transform.parent)
                                        {
                                            member.instance = null;
                                            n.owner         = UNR;
                                            return(true);
                                        }
                                        //return true;
                                    }
                                }
                            }
                            return(false);
                        };
                        if (node as StateNode)
                        {
                            StateNode         eventNode = node as StateNode;
                            TransitionEvent[] TE        = eventNode.GetTransitions();
                            foreach (TransitionEvent n in TE)
                            {
                                var tn = n.GetTargetNode();
                                if (tn == null)
                                {
                                    continue;
                                }
                                if (CopyedObjectMap.ContainsKey(tn))
                                {
                                    n.target = MemberData.CreateConnection(CopyedObjectMap[tn] as Node, true);
                                    n.owner  = UNR;
                                }
                                else if (n.owner != UNR || tn != null && tn.owner != UNR ||
                                         tn != null && tn.transform.parent != node.transform.parent)
                                {
                                    n.target = MemberData.none;
                                    n.owner  = UNR;
                                }
                            }
                        }
                        else if (node is IMacro || node is ISuperNode)
                        {
                            var fields = EditorReflectionUtility.GetFields(comp.GetType());
                            foreach (var field in fields)
                            {
                                if (field.FieldType == typeof(List <Nodes.MacroPortNode>))
                                {
                                    var value = field.GetValueOptimized(comp) as List <Nodes.MacroPortNode>;
                                    if (value != null)
                                    {
                                        foreach (var v in value)
                                        {
                                            AnalizerUtility.AnalizeObject(v, validation);
                                        }
                                    }
                                }
                            }
                        }
                        AnalizerUtility.AnalizeObject(node, validation);
                        node.editorRect = new Rect(node.editorRect.x - center.x + position.x, node.editorRect.y - center.y + position.y, node.editorRect.width, node.editorRect.height);
                        if (node.owner != UNR)
                        {
                            node.owner = UNR;
                        }
                    }
                    else if (comp is BaseEventNode)
                    {
                        BaseEventNode method = comp as BaseEventNode;
                        var           flows  = method.GetFlows();
                        for (int i = 0; i < flows.Count; i++)
                        {
                            var tn = flows[i].GetTargetNode();
                            if (tn != null && CopyedObjectMap.ContainsKey(tn))
                            {
                                flows[i] = new MemberData(CopyedObjectMap[flows[i].GetTargetNode()], MemberData.TargetType.FlowNode);
                            }
                            else if (method.owner != UNR)
                            {
                                flows[i] = MemberData.none;
                            }
                        }
                        method.owner      = UNR;
                        method.editorRect = new Rect(method.editorRect.x - center.x + position.x, method.editorRect.y - center.y + position.y, method.editorRect.width, method.editorRect.height);
                    }
                }
                loopIndex++;
                progress = (float)loopIndex / (float)nodeToCopy.Count;
                if (nodeToCopy.Count > 5)
                {
                    EditorUtility.DisplayProgressBar("Loading", "", progress);
                }
            }
            if (nodeToCopy.Count > 5)
            {
                EditorUtility.ClearProgressBar();
            }
            if (needReflectedComponent.Count > 0)
            {
                NodeEditorUtility.PerformReflectComponent(needReflectedComponent.ToList(), compEvent, UNR);
            }
            foreach (KeyValuePair <uNodeComponent, uNodeComponent> keys in CopyedObjectMap)
            {
                if (keys.Value != null)
                {
                    Undo.RegisterCreatedObjectUndo(keys.Value.gameObject, "Paste Node");
                }
            }
            //allCopyedEvent.Clear();
            Refresh();
        }
Esempio n. 14
0
 /// <summary>
 /// True if group node has instance variable.
 /// </summary>
 /// <param name="groupNode"></param>
 /// <returns></returns>
 public static bool NeedInstanceVariable <T>(T superNode) where T : ISuperNode
 {
     if (superNode != null)
     {
         var flows = new HashSet <NodeComponent>();
         foreach (var n in superNode.nestedFlowNodes)
         {
             FindFlowConnectionAfterCoroutineNode(n, ref flows);
         }
         bool check = false;
         Func <object, bool> validation = null;
         validation = delegate(object obj) {
             if (obj is MemberData)
             {
                 MemberData member = obj as MemberData;
                 Node       n      = member.GetInstance() as Node;
                 if (n != null)
                 {
                     if (n is IVariableSystem && n is T && n == superNode as UnityEngine.Object &&
                         (member.targetType == MemberData.TargetType.uNodeVariable ||
                          member.targetType == MemberData.TargetType.uNodeGroupVariable ||
                          member.targetType == MemberData.TargetType.uNodeLocalVariable))
                     {
                         check = true;
                     }
                     else if (member.targetType == MemberData.TargetType.ValueNode)
                     {
                         AnalizerUtility.AnalizeObject(n, validation);
                     }
                 }
             }
             return(check);
         };
         foreach (Node node in flows)
         {
             if (node == null)
             {
                 continue;
             }
             AnalizerUtility.AnalizeObject(node, validation);
             if (check)
             {
                 return(true);
             }
         }
         var allConnection = new HashSet <NodeComponent>();
         foreach (var n in superNode.nestedFlowNodes)
         {
             FindAllNodeConnection(n, ref allConnection);
         }
         foreach (Node node in allConnection)
         {
             if (node == null)
             {
                 continue;
             }
             AnalizerUtility.AnalizeObject(node, validation);
             if (check)
             {
                 var nodes = GetFlowConnectedTo(node);
                 if (nodes.Count > 0)
                 {
                     if (nodes.Any(n => !flows.Contains(n)))
                     {
                         return(true);
                     }
                 }
                 if ((generatorData.ungroupedNode.Contains(node) || generatorData.portableActionInNode.Contains(node)))
                 {
                     return(true);
                 }
             }
         }
     }
     return(false);
 }
Esempio n. 15
0
        private static void RefactorFunction(uNodeFunction function, string name, Type returnType, Type[] paramTypes)
        {
            var graph = function.owner;

            Undo.SetCurrentGroupName("Refactor Function: " + function.Name);
            HashSet <GameObject> referencedGraphs = new HashSet <GameObject>();

            if (graph != null)
            {
                RuntimeMethod runtime = null;
                if (graph is IIndependentGraph)
                {
                    if (GraphUtility.IsTempGraphObject(graph.gameObject))
                    {
                        var prefab = uNodeEditorUtility.GetGameObjectSource(graph.gameObject, null);
                        if (prefab != null)
                        {
                            var oriGraph = prefab.GetComponent <uNodeRoot>();
                            if (oriGraph != null)
                            {
                                var methods = ReflectionUtils.GetRuntimeType(oriGraph).GetMethods();
                                foreach (var m in methods)
                                {
                                    if (m is RuntimeMethod && m.Name == name)
                                    {
                                        var parameters = m.GetParameters();
                                        if (parameters.Length == paramTypes.Length)
                                        {
                                            if (runtime == null)
                                            {
                                                runtime = m as RuntimeMethod;
                                            }
                                            bool isValid = true;
                                            for (int i = 0; i < parameters.Length; i++)
                                            {
                                                if (parameters[i].ParameterType != paramTypes[i])
                                                {
                                                    isValid = false;
                                                    break;
                                                }
                                            }
                                            if (isValid)
                                            {
                                                runtime = m as RuntimeMethod;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        var methods = ReflectionUtils.GetRuntimeType(graph).GetMethods();
                        foreach (var m in methods)
                        {
                            if (m is RuntimeGraphMethod runtimeMethod && runtimeMethod.target == function)
                            {
                                runtime = runtimeMethod;
                                break;
                            }
                        }
                    }
                }
                MemberInfo nativeMember = null;
                if (graph.GeneratedTypeName.ToType(false) != null)
                {
                    var type = graph.GeneratedTypeName.ToType(false);
                    if (paramTypes.Length == 0 && function.GenericParameters.Count == 0)
                    {
                        nativeMember = type.GetMethod(name, MemberData.flags);
                    }
                    var members = type.GetMember(name, MemberData.flags);
                    if (members != null)
                    {
                        var genericLength = function.GenericParameters.Count;
                        foreach (var m in members)
                        {
                            if (m is MethodInfo method)
                            {
                                var mParam   = method.GetParameters();
                                var mGeneric = method.GetGenericArguments();
                                if (paramTypes.Length == mParam.Length && mGeneric.Length == genericLength)
                                {
                                    bool valid = true;
                                    for (int i = 0; i < mParam.Length; i++)
                                    {
                                        if (mParam[i].ParameterType != paramTypes[i])
                                        {
                                            valid = false;
                                            break;
                                        }
                                    }
                                    if (valid)
                                    {
                                        nativeMember = method;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
                var graphPrefabs = uNodeEditorUtility.FindPrefabsOfType <uNodeRoot>();
                foreach (var prefab in graphPrefabs)
                {
                    var        gameObject    = prefab;
                    GameObject prefabContent = null;
                    if (GraphUtility.HasTempGraphObject(prefab))
                    {
                        gameObject = GraphUtility.GetTempGraphObject(prefab);
                    }
                    else if (uNodeEditorUtility.IsPrefab(prefab))
                    {
                        prefabContent = PrefabUtility.LoadPrefabContents(AssetDatabase.GetAssetPath(prefab));
                        gameObject    = prefabContent;
                    }
                    var  scripts = gameObject.GetComponentsInChildren <MonoBehaviour>(true);
                    bool hasUndo = false;
                    Func <object, bool> scriptValidation = (obj) => {
                        MemberData member = obj as MemberData;
                        if (member != null && member.startType is RuntimeType)
                        {
                            var members = member.GetMembers(false);
                            if (members != null)
                            {
                                for (int i = 0; i < members.Length; i++)
                                {
                                    var m = members[i];
                                    if (member.namePath.Length > i + 1)
                                    {
                                        if (m == runtime || m == nativeMember)
                                        {
                                            if (!hasUndo && prefabContent == null)
                                            {
                                                uNodeEditorUtility.RegisterFullHierarchyUndo(gameObject);
                                                hasUndo = true;
                                            }
                                            var path = member.namePath;
                                            path[i + 1] = function.Name;
                                            member.name = string.Join(".", path);
                                            {
                                                var items = member.Items;
                                                if (items.Length > i)
                                                {
                                                    var mVal = MemberData.CreateFromMember(runtime);
                                                    items[i] = mVal.Items[0];
                                                    member.SetItems(items);
                                                }
                                            }
                                            if (m == nativeMember)
                                            {
                                                referencedGraphs.Add(prefab);
                                            }
                                            return(true);
                                        }
                                    }
                                }
                            }
                        }
                        return(false);
                    };
                    if (runtime != null)
                    {
                        bool hasChanged = false;
                        Array.ForEach(scripts, script => {
                            bool flag = AnalizerUtility.AnalizeObject(script, scriptValidation);
                            if (flag)
                            {
                                hasChanged = true;
                                hasUndo    = false;
                                uNodeGUIUtility.GUIChanged(script);
                                uNodeEditorUtility.MarkDirty(script);
                            }
                        });
                        if (hasChanged)
                        {
                            if (gameObject != prefab)
                            {
                                uNodeEditorUtility.RegisterFullHierarchyUndo(prefab);
                                if (prefabContent == null)
                                {
                                    //Save the temporary graph
                                    GraphUtility.AutoSaveGraph(gameObject);
                                }
                                else
                                {
                                    //Save the prefab contents and unload it
                                    uNodeEditorUtility.SavePrefabAsset(gameObject, prefab);
                                }
                            }
                            uNodeEditorUtility.MarkDirty(prefab);
                        }
                    }
                    if (prefabContent != null)
                    {
                        PrefabUtility.UnloadPrefabContents(prefabContent);
                    }
                }
            }
            uNodeEditorUtility.RegisterFullHierarchyUndo(graph.gameObject);
            graph.Refresh();
            Func <object, bool> validation = delegate(object OBJ) {
                return(CallbackRefactorFunction(OBJ, function, name, paramTypes));
            };

            Array.ForEach(graph.nodes, item => AnalizerUtility.AnalizeObject(item, validation));
            if (GraphUtility.IsTempGraphObject(graph.gameObject))
            {
                var prefab = uNodeEditorUtility.GetGameObjectSource(graph.gameObject, null);
                uNodeEditorUtility.RegisterFullHierarchyUndo(prefab);
                GraphUtility.AutoSaveGraph(graph.gameObject);
            }
            uNodeEditor.ClearGraphCache();
            uNodeEditor.window?.Refresh(true);
            DoCompileReferences(graph, referencedGraphs);
        }
Esempio n. 16
0
        public static void RefactorProperty(uNodeProperty property, string name)
        {
            name = uNodeUtility.AutoCorrectName(name);
            var  graph       = property.owner;
            bool hasVariable = false;

            if (graph.Properties != null && graph.Properties.Count > 0)
            {
                foreach (var V in graph.Properties)
                {
                    if (V.Name == name)
                    {
                        hasVariable = true;
                        break;
                    }
                }
            }
            if (graph.Variables != null && graph.Variables.Count > 0)
            {
                foreach (var V in graph.Variables)
                {
                    if (V.Name == name)
                    {
                        hasVariable = true;
                        break;
                    }
                }
            }
            if (hasVariable)
            {
                return;
            }
            Undo.SetCurrentGroupName("Rename Property: " + property.Name);
            HashSet <GameObject> referencedGraphs = new HashSet <GameObject>();

            if (graph != null)
            {
                RuntimeProperty runtime = null;
                if (graph is IIndependentGraph)
                {
                    if (GraphUtility.IsTempGraphObject(graph.gameObject))
                    {
                        var prefab = uNodeEditorUtility.GetGameObjectSource(graph.gameObject, null);
                        if (prefab != null)
                        {
                            var oriGraph = prefab.GetComponent <uNodeRoot>();
                            if (oriGraph != null)
                            {
                                runtime = ReflectionUtils.GetRuntimeType(oriGraph).GetProperty(property.Name) as RuntimeProperty;
                            }
                        }
                    }
                    else
                    {
                        runtime = ReflectionUtils.GetRuntimeType(graph).GetProperty(property.Name) as RuntimeProperty;
                    }
                }
                PropertyInfo nativeMember = null;
                if (graph.GeneratedTypeName.ToType(false) != null)
                {
                    var type = graph.GeneratedTypeName.ToType(false);
                    nativeMember = type.GetProperty(property.Name, MemberData.flags);
                }
                var graphPrefabs = uNodeEditorUtility.FindPrefabsOfType <uNodeRoot>();
                foreach (var prefab in graphPrefabs)
                {
                    var        gameObject    = prefab;
                    GameObject prefabContent = null;
                    if (GraphUtility.HasTempGraphObject(prefab))
                    {
                        gameObject = GraphUtility.GetTempGraphObject(prefab);
                    }
                    else if (uNodeEditorUtility.IsPrefab(prefab))
                    {
                        prefabContent = PrefabUtility.LoadPrefabContents(AssetDatabase.GetAssetPath(prefab));
                        gameObject    = prefabContent;
                    }
                    var  scripts = gameObject.GetComponentsInChildren <MonoBehaviour>(true);
                    bool hasUndo = false;
                    Func <object, bool> scriptValidation = (obj) => {
                        MemberData member = obj as MemberData;
                        if (member != null && member.startType is RuntimeType)
                        {
                            var members = member.GetMembers(false);
                            if (members != null)
                            {
                                for (int i = 0; i < members.Length; i++)
                                {
                                    var m = members[i];
                                    if (member.namePath.Length > i + 1)
                                    {
                                        if (m == runtime || m == nativeMember)
                                        {
                                            if (!hasUndo && prefabContent == null)
                                            {
                                                uNodeEditorUtility.RegisterFullHierarchyUndo(gameObject);
                                                hasUndo = true;
                                            }
                                            var path = member.namePath;
                                            path[i + 1] = name;
                                            member.name = string.Join(".", path);
                                            if (m == nativeMember)
                                            {
                                                referencedGraphs.Add(prefab);
                                            }
                                            return(true);
                                        }
                                    }
                                }
                            }
                        }
                        return(false);
                    };
                    if (runtime != null || nativeMember != null)
                    {
                        bool hasChanged = false;
                        Array.ForEach(scripts, script => {
                            bool flag = AnalizerUtility.AnalizeObject(script, scriptValidation);
                            if (flag)
                            {
                                hasChanged = true;
                                hasUndo    = false;
                                uNodeGUIUtility.GUIChanged(script);
                                uNodeEditorUtility.MarkDirty(script);
                            }
                        });
                        if (hasChanged)
                        {
                            if (gameObject != prefab)
                            {
                                uNodeEditorUtility.RegisterFullHierarchyUndo(prefab);
                                if (prefabContent == null)
                                {
                                    //Save the temporary graph
                                    GraphUtility.AutoSaveGraph(gameObject);
                                }
                                else
                                {
                                    //Save the prefab contents and unload it
                                    uNodeEditorUtility.SavePrefabAsset(gameObject, prefab);
                                }
                            }
                            uNodeEditorUtility.MarkDirty(prefab);
                        }
                    }
                    if (prefabContent != null)
                    {
                        PrefabUtility.UnloadPrefabContents(prefabContent);
                    }
                }
            }
            uNodeEditorUtility.RegisterFullHierarchyUndo(graph.gameObject);
            string oldVarName = property.Name;

            property.Name = name;
            graph.Refresh();
            Func <object, bool> validation = delegate(object OBJ) {
                return(CallbackRenameProperty(OBJ, graph, property.name, oldVarName));
            };

            Array.ForEach(graph.nodes, item => AnalizerUtility.AnalizeObject(item, validation));
            if (GraphUtility.IsTempGraphObject(graph.gameObject))
            {
                var prefab = uNodeEditorUtility.GetGameObjectSource(graph.gameObject, null);
                uNodeEditorUtility.RegisterFullHierarchyUndo(prefab);
                GraphUtility.AutoSaveGraph(graph.gameObject);
            }
            uNodeEditor.ClearGraphCache();
            uNodeEditor.window?.Refresh(true);
            DoCompileReferences(graph, referencedGraphs);
        }
Esempio n. 17
0
        public static void RefactorVariable(VariableData variable, string name, UnityEngine.Object owner)
        {
            bool      isLocal = false;
            uNodeRoot graph   = owner as uNodeRoot;

            if (graph == null)
            {
                INode <uNodeRoot> node = owner as INode <uNodeRoot>;
                if (node != null)
                {
                    graph   = node.GetOwner();
                    isLocal = true;
                }
            }
            if (graph != null)
            {
                HashSet <GameObject> referencedGraphs = new HashSet <GameObject>();
                if (!isLocal)
                {
                    RuntimeField field = null;
                    if (graph is IIndependentGraph)
                    {
                        if (GraphUtility.IsTempGraphObject(graph.gameObject))
                        {
                            var prefab = uNodeEditorUtility.GetGameObjectSource(graph.gameObject, null);
                            if (prefab != null)
                            {
                                var oriGraph = prefab.GetComponent <uNodeRoot>();
                                if (oriGraph != null)
                                {
                                    field = ReflectionUtils.GetRuntimeType(oriGraph).GetField(variable.Name) as RuntimeField;
                                }
                            }
                        }
                        else
                        {
                            field = ReflectionUtils.GetRuntimeType(graph).GetField(variable.Name) as RuntimeField;
                        }
                    }
                    FieldInfo nativeMember = null;
                    if (graph.GeneratedTypeName.ToType(false) != null)
                    {
                        var type = graph.GeneratedTypeName.ToType(false);
                        nativeMember = type.GetField(variable.Name, MemberData.flags);
                    }
                    var graphPrefabs = uNodeEditorUtility.FindPrefabsOfType <uNodeRoot>();
                    foreach (var prefab in graphPrefabs)
                    {
                        var        gameObject    = prefab;
                        GameObject prefabContent = null;
                        if (GraphUtility.HasTempGraphObject(prefab))
                        {
                            gameObject = GraphUtility.GetTempGraphObject(prefab);
                        }
                        else if (uNodeEditorUtility.IsPrefab(prefab))
                        {
                            prefabContent = PrefabUtility.LoadPrefabContents(AssetDatabase.GetAssetPath(prefab));
                            gameObject    = prefabContent;
                        }
                        var  scripts = gameObject.GetComponentsInChildren <MonoBehaviour>(true);
                        bool hasUndo = false;
                        Func <object, bool> scriptValidation = (obj) => {
                            MemberData member = obj as MemberData;
                            if (member != null)
                            {
                                var members = member.GetMembers(false);
                                if (members != null)
                                {
                                    for (int i = 0; i < members.Length; i++)
                                    {
                                        var m = members[i];
                                        if (member.namePath.Length > i + 1)
                                        {
                                            if (m == field || m == nativeMember)
                                            {
                                                if (!hasUndo && prefabContent == null)
                                                {
                                                    uNodeEditorUtility.RegisterFullHierarchyUndo(gameObject, "Rename Variable: " + variable.Name);
                                                    hasUndo = true;
                                                }
                                                var path = member.namePath;
                                                path[i + 1] = name;
                                                member.name = string.Join(".", path);
                                                if (m == nativeMember)
                                                {
                                                    referencedGraphs.Add(prefab);
                                                }
                                                return(true);
                                            }
                                        }
                                    }
                                }
                            }
                            return(false);
                        };
                        if (field != null || nativeMember != null)
                        {
                            bool hasChanged = false;
                            Array.ForEach(scripts, script => {
                                bool flag = AnalizerUtility.AnalizeObject(script, scriptValidation);
                                if (flag)
                                {
                                    hasChanged = true;
                                    hasUndo    = false;
                                    uNodeGUIUtility.GUIChanged(script);
                                    uNodeEditorUtility.MarkDirty(script);
                                }
                            });
                            if (hasChanged)
                            {
                                if (gameObject != prefab)
                                {
                                    uNodeEditorUtility.RegisterFullHierarchyUndo(prefab, "Rename Variable: " + variable.Name);
                                    if (prefabContent == null)
                                    {
                                        //Save the temporary graph
                                        GraphUtility.AutoSaveGraph(gameObject);
                                    }
                                    else
                                    {
                                        //Save the prefab contents
                                        uNodeEditorUtility.SavePrefabAsset(gameObject, prefab);
                                    }
                                }
                                uNodeEditorUtility.MarkDirty(prefab);
                            }
                        }
                        if (prefabContent != null)
                        {
                            PrefabUtility.UnloadPrefabContents(prefabContent);
                        }
                    }
                }
                string oldVarName = variable.Name;
                variable.Name = name;
                Func <object, bool> validation = delegate(object OBJ) {
                    return(CallbackRenameVariable(OBJ, owner, variable.Name, oldVarName));
                };
                graph.Refresh();
                Array.ForEach(graph.nodes, item => AnalizerUtility.AnalizeObject(item, validation));
                if (GraphUtility.IsTempGraphObject(graph.gameObject))
                {
                    var prefab = uNodeEditorUtility.GetGameObjectSource(graph.gameObject, null);
                    uNodeEditorUtility.RegisterFullHierarchyUndo(prefab, "Rename Variable: " + oldVarName);
                    GraphUtility.AutoSaveGraph(graph.gameObject);
                }
                uNodeEditor.ClearGraphCache();
                uNodeEditor.window?.Refresh(true);
                DoCompileReferences(graph, referencedGraphs);
            }
        }
Esempio n. 18
0
        public void InitMacroPort(IMacroPort port)
        {
            if (port == null)
            {
                return;
            }
            if (m_port == null)
            {
                m_port = port;
            }
            if (m_port == port)             // Make sure to init macro only one times.
            {
                Refresh();
                if (CodeGenerator.isGenerating)
                {
                    foreach (VariableData variable in variables)
                    {
                        variable.modifier.SetPrivate();
                        CodeGenerator.AddVariable(variable);
                    }
                    m_generatedVariable = new List <VariableData>();
                    //Ensure to register default variable from macro graph
                    var macroVariable = macroAsset.Variables;
                    foreach (var variable in macroVariable)
                    {
                        if (!variables.Any(v => v.Name == variable.Name))
                        {
                            var tmpVar = new VariableData(variable);
                            tmpVar.modifier.SetPrivate();
                            CodeGenerator.AddVariable(tmpVar);
                            m_generatedVariable.Add(tmpVar);
                        }
                    }
                }
                if (macroAsset != null)
                {
                    if (CodeGenerator.isGenerating || Application.isPlaying)
                    {
                        if (runtimeMacro != null)
                        {
                            DestroyImmediate(runtimeMacro.gameObject);
                        }
                        runtimeMacro = uNodeUtility.TempManagement.CreateTempObject(macroAsset);
                        var behaviors = runtimeMacro.RootObject.GetComponentsInChildren <MonoBehaviour>(true);
                        AnalizerUtility.RetargetNodeOwner(runtimeMacro, owner, behaviors, (obj) => {
                            MemberData member = obj as MemberData;
                            if (member != null && member.targetType == MemberData.TargetType.uNodeVariable && GetVariableData(member.startName) != null)
                            {
                                member.RefactorUnityObject(new Object[] { runtimeMacro }, new Object[] { this });
                            }
                        });
                        Dictionary <int, MacroPortNode> portMap = new Dictionary <int, MacroPortNode>();
                        foreach (var p in inputFlows)
                        {
                            if (p != null && p.linkedPort != null)
                            {
                                portMap[p.linkedPort.port.transform.GetSiblingIndex()] = p;
                            }
                        }
                        foreach (var p in inputValues)
                        {
                            if (p != null && p.linkedPort != null)
                            {
                                portMap[p.linkedPort.port.transform.GetSiblingIndex()] = p;
                            }
                        }
                        foreach (var p in outputFlows)
                        {
                            if (p != null && p.linkedPort != null)
                            {
                                portMap[p.linkedPort.port.transform.GetSiblingIndex()] = p;
                            }
                        }
                        foreach (var p in outputValues)
                        {
                            if (p != null && p.linkedPort != null)
                            {
                                portMap[p.linkedPort.port.transform.GetSiblingIndex()] = p;
                            }
                        }
                        foreach (Transform t in runtimeMacro.RootObject.transform)
                        {
                            var comp = t.GetComponent <Node>();
                            if (comp != null)
                            {
                                comp.parentComponent = this;
                                var           p = comp as MacroPortNode;
                                MacroPortNode originP;
                                if (portMap.TryGetValue(t.GetSiblingIndex(), out originP))
                                {
                                    switch (originP.kind)
                                    {
                                    case PortKind.FlowInput:
                                    case PortKind.ValueOutput:
                                        originP.target = new MemberData(p.target);
                                        break;

                                    case PortKind.FlowOutput:
                                    case PortKind.ValueInput:
                                        p.target = new MemberData(originP.target);
                                        break;
                                    }
                                }
                            }
                        }
                        runtimeMacro.SetLinkedOwner(owner);                         //Make sure all get/set property will be liked to actual owner.
                        if (CodeGenerator.isGenerating)
                        {
                            foreach (var b in behaviors)
                            {
                                if (b is NodeComponent)
                                {
                                    CodeGenerator.RegisterAsGroupedNode(b as NodeComponent);
                                }
                            }
                        }
                    }
                }
            }
        }
Esempio n. 19
0
 public void SelectConnectedNode(Component from, bool allConnection = false, Action <NodeComponent> callbackAction = null)
 {
     if (from == null)
     {
         return;
     }
     if (from is BaseEventNode)
     {
         BaseEventNode method = from as BaseEventNode;
         var           flows  = method.GetFlows();
         foreach (var n in flows)
         {
             if (n == null || n.GetTargetNode() == null)
             {
                 continue;
             }
             if (!editorData.selectedNodes.Contains(n.GetTargetNode()))
             {
                 editorData.selectedNodes.Add(n.GetTargetNode());
                 editorData.selected = editorData.selectedNodes;
                 if (allConnection)
                 {
                     SelectConnectedNode(n.GetTargetNode(), allConnection, callbackAction);
                 }
                 SelectionChanged();
                 if (callbackAction != null)
                 {
                     callbackAction(n.GetTargetNode());
                 }
             }
         }
     }
     else if (from is Node)
     {
         Node node = from as Node;
         if (node as StateNode)
         {
             StateNode         eventNode = node as StateNode;
             TransitionEvent[] TE        = eventNode.GetTransitions();
             foreach (TransitionEvent T in TE)
             {
                 if (T.GetTargetNode() != null)
                 {
                     if (!editorData.selectedNodes.Contains(T.GetTargetNode()))
                     {
                         editorData.selectedNodes.Add(T.GetTargetNode());
                         editorData.selected = editorData.selectedNodes;
                         if (allConnection)
                         {
                             SelectConnectedNode(T.GetTargetNode(), allConnection, callbackAction);
                         }
                         SelectionChanged();
                         if (callbackAction != null)
                         {
                             callbackAction(T.GetTargetNode());
                         }
                     }
                 }
             }
         }
         Func <object, bool> validation = delegate(object o) {
             if (o is MemberData)
             {
                 MemberData member = o as MemberData;
                 if (member.targetType == MemberData.TargetType.FlowNode ||
                     member.targetType == MemberData.TargetType.ValueNode)
                 {
                     Node n = member.GetInstance() as Node;
                     if (member.isAssigned && member.GetInstance() is Node)
                     {
                         if (!editorData.selectedNodes.Contains(n))
                         {
                             editorData.selectedNodes.Add(n);
                             editorData.selected = editorData.selectedNodes;
                             if (allConnection)
                             {
                                 SelectConnectedNode(n, allConnection, callbackAction);
                             }
                             SelectionChanged();
                             if (callbackAction != null)
                             {
                                 callbackAction(n);
                             }
                         }
                         //return true;
                     }
                 }
             }
             return(false);
         };
         AnalizerUtility.AnalizeObject(node, validation);
     }
 }
Esempio n. 20
0
 public static HashSet <NodeComponent> GetFlowConnectedTo(Node target)
 {
     if (target != null)
     {
         if (generatorData.FlowConnectedTo.TryGetValue(target, out var comp))
         {
             return(comp);
         }
         comp = new HashSet <NodeComponent>();
         Node currNode = null;
         Func <object, bool> validation = delegate(object obj) {
             if (obj is MemberData)
             {
                 MemberData member     = obj as MemberData;
                 Node       targetNode = member.GetTargetNode();
                 if (targetNode == target)
                 {
                     if (member.targetType == MemberData.TargetType.FlowNode || member.targetType == MemberData.TargetType.FlowInput)
                     {
                         comp.Add(currNode);
                         return(true);
                     }
                     else if (member.targetType == MemberData.TargetType.ValueNode ||
                              member.targetType == MemberData.TargetType.NodeField ||
                              member.targetType == MemberData.TargetType.NodeFieldElement)
                     {
                         var connectedNodes = GetFlowConnectedTo(currNode);
                         if (connectedNodes != null)
                         {
                             foreach (var n in connectedNodes)
                             {
                                 comp.Add(n);
                             }
                         }
                     }
                 }
             }
             return(false);
         };
         foreach (Node node in generatorData.allNode)
         {
             if (target == node)
             {
                 continue;
             }
             if (node is StateNode)
             {
                 StateNode         eventNode = node as StateNode;
                 TransitionEvent[] TE        = eventNode.GetTransitions();
                 foreach (TransitionEvent transition in TE)
                 {
                     if (transition != null && transition.GetTargetNode() == target)
                     {
                         comp.Add(node);
                         break;
                     }
                 }
             }
             else if (node is IMacro)
             {
                 IMacro macro       = node as IMacro;
                 var    outputFlows = macro.OutputFlows;
                 foreach (var flow in outputFlows)
                 {
                     if (flow != null && flow.target.GetTargetNode() == target)
                     {
                         comp.Add(node);
                         break;
                     }
                 }
             }
             currNode = node;
             AnalizerUtility.AnalizeObject(node, validation);
         }
         foreach (EventNode method in generatorData.eventNodes)
         {
             if (method == null)
             {
                 continue;
             }
             foreach (var flow in method.GetFlows())
             {
                 if (flow.GetTargetNode() == target)
                 {
                     comp.Add(method);
                     break;
                 }
             }
         }
         generatorData.FlowConnectedTo[target] = comp;
         return(comp);
     }
     return(null);
 }
Esempio n. 21
0
        public override void OnClick(Node source, Vector2 mousePosition)
        {
            MacroNode node = source as MacroNode;
            string    path = EditorUtility.SaveFilePanelInProject("Export to macro asset",
                                                                  "New Macro.prefab",
                                                                  "prefab",
                                                                  "Please enter a file name to save the macro to");

            if (path.Length != 0)
            {
                Undo.RegisterFullObjectHierarchyUndo(node, "");
                Undo.RegisterFullObjectHierarchyUndo(node.owner, "");
                var        tmpMacro = Object.Instantiate(node);
                GameObject go       = new GameObject("New Macro");
                var        macro    = go.AddComponent <uNodeMacro>();
                macro.Variables.AddRange(tmpMacro.Variables);
                if (macro.RootObject == null)
                {
                    macro.RootObject = new GameObject("Root");
                    macro.RootObject.transform.SetParent(macro.transform);
                }
                var behaviors = tmpMacro.GetComponentsInChildren <MonoBehaviour>(true);
                AnalizerUtility.RetargetNodeOwner(tmpMacro.owner, macro, behaviors, (obj) => {
                    MemberData member = obj as MemberData;
                    if (member != null && member.targetType == MemberData.TargetType.uNodeVariable && member.GetInstance() as Object == tmpMacro)
                    {
                        member.RefactorUnityObject(new Object[] { tmpMacro }, new Object[] { macro });
                    }
                });
                for (int i = 0; i < tmpMacro.transform.childCount; i++)
                {
                    tmpMacro.transform.GetChild(i).SetParent(macro.RootObject.transform);
                    i--;
                }
                macro.Refresh();
#if UNITY_2018_3_OR_NEWER
                GameObject prefab = PrefabUtility.SaveAsPrefabAsset(go, path);
#else
                GameObject prefab = PrefabUtility.CreatePrefab(path, go);
#endif
                AssetDatabase.SaveAssets();
                Object.DestroyImmediate(go);
                Object.DestroyImmediate(tmpMacro.gameObject);
                var macroAsset = prefab.GetComponent <uNodeMacro>();
                NodeEditorUtility.AddNewNode(graph.editorData, null, null, mousePositionOnCanvas, (LinkedMacroNode n) => {
                    n.macroAsset = macroAsset;
                    n.editorRect = node.editorRect;
                    NodeEditorUtility.AddNewObject(graph.editorData.graph, "pins", n.transform, (pin) => {
                        n.pinObject = pin;
                        n.Refresh();
                        RefactorUtility.RetargetNode(node, n);
                        if (n.inputFlows.Count == node.inputFlows.Count)
                        {
                            for (int i = 0; i < n.inputFlows.Count; i++)
                            {
                                RefactorUtility.RetargetNode(node.inputFlows[i], n.inputFlows[i]);
                            }
                        }
                        if (n.inputValues.Count == node.inputValues.Count)
                        {
                            for (int i = 0; i < n.inputValues.Count; i++)
                            {
                                n.inputValues[i].target = new MemberData(node.inputValues[i].target);
                            }
                        }
                        if (n.outputFlows.Count == node.outputFlows.Count)
                        {
                            for (int i = 0; i < n.outputFlows.Count; i++)
                            {
                                n.outputFlows[i].target = new MemberData(node.outputFlows[i].target);
                            }
                        }
                        if (n.outputValues.Count == node.outputValues.Count)
                        {
                            for (int i = 0; i < n.outputValues.Count; i++)
                            {
                                RefactorUtility.RetargetNode(node.outputValues[i], n.outputValues[i]);
                            }
                        }
                    });
                });
                NodeEditorUtility.RemoveNode(graph.editorData, node);
            }
            graph.Refresh();
        }