示例#1
0
        /// <summary>
        /// Updates the nodes order.
        /// </summary>
        void UpdateNodes()
        {
            var oldNodes = GetNodes();

            // Get all root nodes
            var rootNodes = new List <ActionNode>();

            foreach (ActionNode n in oldNodes)
            {
                if (n.isRoot)
                {
                    rootNodes.Add(n);
                }
            }

            var newNodes = new List <ActionNode>();

            for (int i = 0; i < rootNodes.Count; i++)
            {
                BranchNode branch = rootNodes[i] as BranchNode;
                if (branch != null)
                {
                    newNodes.AddRange(branch.GetHierarchy());
                }
                else
                {
                    newNodes.Add(rootNodes[i]);
                }
            }
            m_Nodes = newNodes.ToArray();
        }
示例#2
0
        /// <summary>
        /// Returns the branch hierarchy nodes.
        /// <returns>Tha branch node and all children/subchildren.<returns>
        /// </summary>
        public ActionNode[] GetHierarchy()
        {
            List <ActionNode> allNodes = new List <ActionNode>()
            {
                this
            };

            {
                var __array1       = this.children;
                var __arrayLength1 = __array1.Length;
                for (int __i1 = 0; __i1 < __arrayLength1; ++__i1)
                {
                    var child = (ActionNode)__array1[__i1];
                    {
                        BranchNode childBranch = child as BranchNode;
                        if (childBranch != null)
                        {
                            allNodes.AddRange(childBranch.GetHierarchy());
                        }
                        else
                        {
                            allNodes.Add(child);
                        }
                    }
                }
            }
            return(allNodes.ToArray());
        }
示例#3
0
        /// <summary>
        /// Removes node from tree.
        /// <param name="node">The node to be removed.</param>
        /// <param name="includeHierarchy">If true, the hierarchy will also be removed.</param>
        /// </summary>
        public void RemoveNode(ActionNode node, bool includeHierarchy)
        {
            GetNodes();
            var        nodes  = new List <ActionNode>(m_Nodes);
            BranchNode branch = node as BranchNode;

            // Remove children
            if (includeHierarchy && branch != null)
            {
                foreach (ActionNode n in branch.GetHierarchy())
                {
                    nodes.Remove(n);
                }
            }

            // Remove node
            nodes.Remove(node);
            m_Nodes = nodes.ToArray();

            if (Application.isPlaying && this.enabled)
            {
                // Update function nodes
                m_FunctionNodes = this.GetFunctionNodes();
                // Reset status
                node.ResetStatus();
                // Disable node
                node.OnDisable();
            }

            HierarchyChanged();
        }
示例#4
0
 /// <summary> 
 /// Returns True if the supplied branch is in an ancestor of the node.
 /// <param name="branch">The branch to test is an ancestor</param>
 /// <returns>True if the node is in the supplied branch hierarchy; False otherwise.</returns>
 /// </summary>
 protected bool IsAncestor (BranchNode branch) {
     // The branch is not a grandfather
     for  (var grandfather = this.branch; grandfather != null; grandfather = grandfather.branch) {
         if (grandfather == branch)
             return true;
     }
     return false;
 }
示例#5
0
 /// <summary>
 /// Returns True if the supplied branch is in an ancestor of the node.
 /// <param name="branch">The branch to test is an ancestor</param>
 /// <returns>True if the node is in the supplied branch hierarchy; False otherwise.</returns>
 /// </summary>
 protected bool IsAncestor(BranchNode branch)
 {
     // The branch is not a grandfather
     for (var grandfather = this.branch; grandfather != null; grandfather = grandfather.branch)
     {
         if (grandfather == branch)
         {
             return(true);
         }
     }
     return(false);
 }
示例#6
0
        /// <summary>
        /// Returns the branch hierarchy nodes.
        /// <returns>Tha branch node and all children/subchildren.<returns>
        /// </summary>
        public ActionNode[] GetHierarchy()
        {
            List <ActionNode> allNodes = new List <ActionNode>()
            {
                this
            };

            foreach (ActionNode child in this.children)
            {
                BranchNode childBranch = child as BranchNode;
                if (childBranch != null)
                {
                    allNodes.AddRange(childBranch.GetHierarchy());
                }
                else
                {
                    allNodes.Add(child);
                }
            }

            return(allNodes.ToArray());
        }
示例#7
0
        /// <summary>
        /// Removes node from tree.
        /// <param name="node">The node to be removed.</param>
        /// <param name="includeHierarchy">If true, the hierarchy will also be removed.</param>
        /// </summary>
        public void RemoveNode(ActionNode node, bool includeHierarchy)
        {
            GetNodes();
            var        nodes  = new List <ActionNode>(m_Nodes);
            BranchNode branch = node as BranchNode;

            // Remove children
            if (includeHierarchy && branch != null)
            {
                {
                    var __array3       = branch.GetHierarchy();
                    var __arrayLength3 = __array3.Length;
                    for (int __i3 = 0; __i3 < __arrayLength3; ++__i3)
                    {
                        var n = (ActionNode)__array3[__i3];
                        {
                            nodes.Remove(n);
                        }
                    }
                }
            }

            // Remove node
            nodes.Remove(node);
            m_Nodes = nodes.ToArray();

            if (Application.isPlaying && this.enabled)
            {
                // Update function nodes
                m_FunctionNodes = this.GetFunctionNodes();
                // Reset status
                node.ResetStatus();
                // Disable node
                node.OnDisable();
            }

            HierarchyChanged();
        }
示例#8
0
        /// <summary>
        /// Updates the nodes order.
        /// </summary>
        void UpdateNodes()
        {
            var oldNodes = GetNodes();

            // Get all root nodes
            var rootNodes = new List <ActionNode>();
            {
                // foreach(var n in oldNodes)
                var __enumerator1 = (oldNodes).GetEnumerator();
                while (__enumerator1.MoveNext())
                {
                    var n = (ActionNode)__enumerator1.Current;
                    {
                        if (n.isRoot)
                        {
                            rootNodes.Add(n);
                        }
                    }
                }
            }

            var newNodes = new List <ActionNode>();

            for (int i = 0; i < rootNodes.Count; i++)
            {
                BranchNode branch = rootNodes[i] as BranchNode;
                if (branch != null)
                {
                    newNodes.AddRange(branch.GetHierarchy());
                }
                else
                {
                    newNodes.Add(rootNodes[i]);
                }
            }
            m_Nodes = newNodes.ToArray();
        }
示例#9
0
 /// <summary>
 /// Sets a new drop and/or insertion. Changes the drag and drop logic.
 /// <returns>True if the drop target has changed; false otherwise.</returns>
 /// </summary>
 public bool SetDrop (ActionNode drop, bool insertion) {
     if (m_Drop != drop || (insertion && m_Insertion != drop) || (!insertion && m_Insertion != null)) {
         if (insertion) {
             m_Insertion = drop;
             m_Drop = drop.branch;
         }
         else {
             m_Drop = drop as BranchNode;
             m_Insertion = null;
         }
         return true;
     }
     return false;
 }
示例#10
0
        /// <summary>
        /// Callback to create a new child node.
        /// <param name="type">The new node type.</param>
        /// <param name="branch">The branch of the new node; or null if its a root node.</param>
        /// </summary>
        void OnAddNewNode (System.Type type, BranchNode branch) {
            ActionNode newNode = null;
            InternalBehaviourTree activeTree = BehaviourWindow.activeTree;

            // Add node
            if (branch != null)
                newNode = BehaviourTreeUtility.AddNode(branch, type);
            else if (activeTree != null)
                newNode = BehaviourTreeUtility.AddNode(activeTree, type);

            if (newNode != null) {
                // Is the new node a child of the branch?
                if (branch != null && newNode.branch == branch)
                    SetExpanded(branch.instanceID, true);   // Expand branch

                // Select newNode
                BehaviourWindow.activeNodeID = newNode.instanceID;

                // Update data
                Refresh();
            }
        }
示例#11
0
        /// <summary>
        /// Callback to paste a node.
        /// <param name="parent">The parent node to be pasted or null to paste as a root node.</param>
        /// </summary>
        void OnPasteNode (BranchNode parent) {
            var newNode = BehaviourTreeUtility.PasteNode(BehaviourWindow.activeTree, parent);

            if (newNode != null) {
                // Select newNode
                BehaviourWindow.activeNodeID = newNode.instanceID;
                // Update data
                Refresh();
            }
        }
示例#12
0
        /// <summary>
        /// Callback to remove a branch.
        /// <param name="branch">The target branch to be removed.</param>
        /// </summary>
        void OnRemoveBranch (BranchNode branch) {
            if (branch != null && BehaviourTreeUtility.RemoveBranch(branch)) {
                // Forces node selection update
                BehaviourWindow.activeNodeID = 0;

                // Removes branch from expanded list
                if (m_Expanded.Contains(branch.instanceID))
                    SetExpanded(branch.instanceID, false);

                Refresh();
            }
        }
示例#13
0
        /// <summary> 
        /// Updates current node by incremeting m_CurrentNodeIndex).
        /// </summary>
        void GoToNextNode () {
            m_CurrentNodeIndex++;

            if (m_CurrentNodeIndex >= 0 && m_CurrentNodeIndex < m_Nodes.Count) {
                m_CurrentNode = m_Nodes[m_CurrentNodeIndex];
                m_CurrentBranch = m_CurrentNode as BranchNode;
                m_CurrentFunction = m_CurrentBranch != null ? m_CurrentBranch as FunctionNode : null;
            }
            else {
                m_CurrentNode = null;
                m_CurrentBranch = null;
                m_CurrentFunction = null;
                m_CurrentNodeIndex = -1;
                m_IsValid = false;
            }
        }
示例#14
0
        /// <summary> 
        /// Remove the suplied branch from the tree.
        /// <param name="branch">The node to be removed.</param>
        /// <returns>True if the node was successfully removed; false otherwise.</returns>
        /// </summary>
        public static bool RemoveBranch (BranchNode branch) {
            // The Branch is not a decorator
            if (branch != null && branch.tree != null) {
                // Gets parent's children and node's id
                var parent = branch.branch;
                ActionNode[] children = branch.children;
                var tree = branch.tree;             

                // The parent is a decorator or null (node is root) and the branch has more than one child?
                if (children.Length >= 2 && (parent == null || parent is DecoratorNode) || parent == null) {
                    EditorApplication.Beep();
                    return false;
                }

                // Register Undo
                #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                Undo.RegisterUndo(branch.tree, "Remove Branch");
                #else
                Undo.RecordObject(branch.tree, "Remove Branch");
                #endif

                // Removes children from branch and adds to parent
                if (parent != null) {
                    // Get the branch index
                    int branchIndex = (new List<ActionNode>(parent.children)).IndexOf(branch);
                    parent.Remove(branch);

                    for (int i = 0; i < children.Length; i++) {
                        branch.Remove(children[i]);
                        parent.Insert(branchIndex++, children[i]);
                    }

                    // Call OnValidate on the parent
                    parent.OnValidate();
                }

                // Removes node from tree
                tree.RemoveNode(branch, false);

                // Saves tree and marks dirty flag
                StateUtility.SetDirty(tree);

                return true;
            }
            return false;
        }
示例#15
0
        /// <summary> 
        /// Paste the node in BehaviourTreeUtility.nodeToPaste in the supplied tree.
        /// <param name="tree">The target tree.</param>
        /// <param name="parent">Optional parent to paste the node; or null to paste as a root node.</param>
        /// <returns>The pasted node.</returns>
        /// </summary>
        public static ActionNode PasteNode (InternalBehaviourTree tree, BranchNode parent = null) {
            // Get the node to be pasted
            var node = BehaviourTreeUtility.nodeToPaste;

            // Validate parameters
            if (node != null && tree != null) {
                // Register Undo
                #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                Undo.RegisterUndo(tree,"Paste Node");
                #else
                Undo.RecordObject(tree,"Paste Node");
                #endif

                var newNode = node.Copy(tree);

                if (newNode != null) {
                    // Add to parent branch?
                    if (parent != null) {
                        parent.Add(newNode);

                        // Call OnValidate on the parent
                        parent.OnValidate();
                    }

                    // Saves node and sets dirty flag
                    StateUtility.SetDirty(tree);

                    // Reload tree to update variables
                    tree.LoadNodes();
                }
                return newNode;
            }
            return null;
        }
示例#16
0
        /// <summary> 
        /// Inserts a new node to the supplied branch, automatically handles undo, dirty flag and save node.
        /// <param name="node">The branch to add a new node.</param>
        /// <param name="newNodePosition">Move the node to the position of this node.</param>
        /// <param name="branch">The branch to drop the node or null.</param>
        /// </summary>
        public static bool MoveNode (ActionNode node, ActionNode newNodePosition, BranchNode branch) {
            // Validate parameters
            if (node != null  && node.tree != null) {
                // Get the tree
                var tree = node.tree;

                // The node does not belongs to the tree?
                if (!tree.GetNodes().Contains(node))
                    return false;

                // Register Undo
                #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                Undo.RegisterUndo(tree,"Move Node");
                #else
                Undo.RecordObject(tree,"Move Node");
                #endif

                // The node will be a root node?
                if (branch == null) {
                    // Remove from old branch
                    if (node.branch != null) {
                        BranchNode oldBranch = node.branch;
                        node.branch.Remove(node);

                        // Call OnValidate on old branch
                        oldBranch.OnValidate();
                    }

                    if (newNodePosition == null) {
                        var newIndex = node.tree.GetNodes().Count - 1;
                        node.tree.MoveNode(node.GetIndex(), newIndex);
                    }
                    else {
                        var newIndex = newNodePosition.root.GetIndex();
                        node.tree.MoveNode(node.GetIndex(), newIndex);
                    }
                }
                // The new node position is null?
                else if (newNodePosition == null) {
                    // node.branch = branch;
                    // Store old branch
                    var oldBranch = node.branch;

                    // Remove from old branch
                    if (oldBranch != null) {
                        oldBranch.Remove(node);
                    }

                    // Add to drop
                    if (!branch.Add(node)) {
                        // Restore old branch
                        if (oldBranch != null)
                            oldBranch.Add(node);
                        return false;
                    }

                    // Call OnValidate on branches
                    branch.OnValidate();
                    if (oldBranch != null && oldBranch != branch)
                        oldBranch.OnValidate();

                    node.tree.HierarchyChanged();
                }
                else {
                    // Cache the oldBranch
                    BranchNode oldBranch = node.branch;

                    // Get index
                    var index = -1;
                    var children = branch.children;
                    for (int i = 0; i < children.Length; i++) {
                        if (children[i] == newNodePosition) {
                            index = i;
                            break;
                        }
                    }

                    // The index is invalid?
                    if (index < 0 || !branch.Insert(index, node)) {
                        return false;
                    }
                    else {
                        // Call OnValidate on the branches
                        if (oldBranch != null)
                            oldBranch.OnValidate();
                        branch.OnValidate();
                        node.tree.HierarchyChanged();
                    } 
                }

                // Save move opration
                StateUtility.SetDirty(tree);

                return true;
            }
            return false;
        }
示例#17
0
        /// <summary> 
        /// Inserts a new node to the supplied branch, automatically handles undo, dirty flag and save node.
        /// <param name="branch">The branch to add a new node.</param>
        /// <param name="index">The index of the new node.</param>
        /// <param name="nodeType">The type of the new node.</param>
        /// <returns>The new node.</returns>
        /// </summary>
        public static ActionNode InsertNode (BranchNode branch, int index, System.Type nodeType) {
            // Validate parameters
            if (branch != null  && branch.tree != null && nodeType != null && index >= 0 && index <= branch.children.Length) {
                // Get the tree
                var tree = branch.tree;

                // Register Undo
                #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                Undo.RegisterUndo(tree,"Insert New Node");
                #else
                Undo.RecordObject(tree,"Insert New Node");
                #endif

                // Create new node
                var newNode = tree.AddNode(nodeType);

                if (newNode != null) {  
                    // Insert new node 
                    branch.Insert(index, newNode);

                    // Call OnValidate on the parent
                    branch.OnValidate();

                    // Saves node and sets dirty flag
                    StateUtility.SetDirty(tree);
                    return newNode;
                }

            }
            return null;
        }
示例#18
0
        /// <summary> 
        /// Adds a new node to the parent, automatically handles undo, dirty flag and save node.
        /// <param name="parent">The branch to add the child.</param>
        /// <param name="childType">The type of the new node.</param>
        /// <returns>The new node.</returns>
        /// </summary>
        public static ActionNode AddNode (BranchNode parent, System.Type childType) {
            // Validate parameters
            if (parent != null && parent.tree != null && childType != null) {
                // Register Undo
                #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
                Undo.RegisterUndo(parent.tree,"Add New Node");
                #else
                Undo.RecordObject(parent.tree,"Add New Node");
                #endif

                var newNode = parent.tree.AddNode(childType);

                if (newNode != null) {
                    // Adds new node as child of parent
                    parent.Add(newNode);

                    // Call OnValidate on the parent
                    parent.OnValidate();

                    // Saves node and sets dirty flag
                    StateUtility.SetDirty(parent.tree);
                    return newNode;
                }
            }

            return null;
        }
示例#19
0
 /// <summary>
 /// Reset the logic to the default values.
 /// </summary>
 public void Reset () {
     m_Target = null;
     m_Drop = null;
     m_Insertion = null;
     m_MonoScript = null;
 }
示例#20
0
        /// <summary> 
        /// Reset members.
        /// </summary>
        public void Reset () {
            if (m_Tree != null)
                m_Nodes = m_Tree.GetNodes();
            else
                m_Nodes = new List<ActionNode>();

            m_CurrentNode = null;
            m_CurrentBranch = null;
            m_CurrentFunction = null;
            m_CurrentNodeIndex = -1;
            m_IsValid = true;
        }
示例#21
0
 int CountNodesInBranch (BranchNode branch) {
     var n = 0;
     foreach (var child in branch.children) {
         n++;
         if (child is BranchNode)
             n += CountNodesInBranch(child as BranchNode);
     }
     return n;
 }