// // Methods // public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent) { UnityVariablePropertyAttribute att = (UnityVariablePropertyAttribute)attribute; BlackboardCustom blackboard = node.blackboard as BlackboardCustom; List<UnityVariable> blackboardLocalList = blackboard.GetVariableBy (att.variableType); List<GUIContent> displayOptionsList = blackboardLocalList.Select ((item) => new GUIContent ("Local/" + item.name)).ToList (); EditorGUILayout.BeginHorizontal (); // property.serializedNode.ApplyModifiedProperties (); EditorGUI.BeginChangeCheck (); //EditorGUILayout.LabelField (att.name,new GUILayoutOption[]{GUILayout.MaxWidth(80)}); property.value = EditorGUILayoutEx.UnityVariablePopup (new GUIContent(att.name), property.value as UnityVariable, att.variableType, displayOptionsList, blackboardLocalList); if (EditorGUI.EndChangeCheck ()) { property.serializedNode.ApplyModifiedProperties (); } EditorGUILayout.EndHorizontal (); }
/// <summary> /// Paste the supplied nodes in the supplied ActionState. /// <param name="actionState">The ActionState to paste the node.</param> /// <param name="nodes">The nodes to be pasted.</param> /// <returns>The pasted nodes.</returns> /// </summary> public static ActionNode[] PasteNodes (InternalActionState actionState, ActionNode[] nodes) { var newNodes = new List<ActionNode>(); // Validate parameters if (nodes != null && actionState != null) { // Register Undo #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2 Undo.RegisterUndo(actionState,"Paste Node"); #else Undo.RecordObject(actionState,"Paste Node"); #endif // Copy nodes for (int i = 0; i < nodes.Length; i++) { if (nodes[i] != null && !(nodes[i] is BranchNode)) { ActionNode newNode = nodes[i].Copy(actionState); if (newNode != null) newNodes.Add(newNode); } } if (newNodes.Count > 0) { // Saves node and sets dirty flag StateUtility.SetDirty(actionState); // Reload actionState to update variables actionState.LoadNodes(); } } return newNodes.ToArray(); }
/// <summary> /// Adds a child node to the branch. /// <param name = "child">The node to be added to the branch.</param> /// <returns>True if the node was added to the list; otherwise false.</returns> /// </summary> public override bool Add (ActionNode child) { if (CanAddNode(child)) { m_Child = child; m_Child.branch = this; return true; } return false; }
/// <summary> /// Set the children in the branch. /// Used during the node's serialization. /// <param name="newChildren">The new child nodes.</param> /// <returns>True if the new children were successfully added; false otherwise.</returns> /// <seealso cref="BehaviourMachine.NodeSerialization" /> /// </summary> public override bool SetChildren (ActionNode[] newChildren) { if (newChildren.Length == 1 && CanAddNode(newChildren[0])) { m_Child = newChildren[0]; m_Child.branch = this; return true; } else if (newChildren.Length <= 0) { if (m_Child != null) m_Child.branch = null; m_Child = null; return true; } return false; }
/// <summary> /// Set the children in the branch. /// Used during the node's serialization. /// <param name="newChildren">The new child nodes.</param> /// <returns>True if the new children was successfully added; false otherwise.</returns> /// <seealso cref="BehaviourMachine.NodeSerialization" /> /// </summary> public override bool SetChildren (ActionNode[] newChildren) { // Validate children for (int i = 0; i < newChildren.Length; i++) { if (!CanAddNode(newChildren[i])) return false; } // Set branch for (int i = 0; i < newChildren.Length; i++) newChildren[i].branch = this; m_Children = newChildren; return true; }
/// <summary> /// A callback invoked whenever a node change its status. /// <param name="node">The target node.</param> /// </summary> private void OnNodeTick (ActionNode node) { // The node belongs to the active tree? if (node.owner as InternalActionState == m_ActionState && node.status != Status.Ready) { // The node status is already been tracked? if (m_NodeStatusTime.ContainsKey(node.instanceID)) { // Update time m_NodeStatusTime[node.instanceID].Update(node.status); } else { // Create a new entry m_NodeStatusTime.Add(node.instanceID, new NodeStatusTime(node.status)); } } }
/// <summary> /// Draw the slider. /// </summary> public override void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent) { // Integer if (property.propertyType == NodePropertyType.Integer) { var range = base.attribute as RangeAttribute; property.value = EditorGUILayout.IntSlider (guiContent, (int)property.value, (int)range.min, (int)range.max); } // Float else if (property.propertyType == NodePropertyType.Float) { var range = base.attribute as RangeAttribute; property.value = EditorGUILayout.Slider (guiContent, (float)property.value, range.min, range.max); } else EditorGUILayout.LabelField(guiContent, new GUIContent("Use range with float or int.")); }
/// <summary> /// Adds the node to the branch nodes list. /// <param name = "child">The node to be added to the list.</param> /// <returns>True if the node was added to the list; otherwise false.</returns> /// </summary> public override bool Add (ActionNode child) { if (CanAddNode(child) && !Contains(child)) { // Remove from old branch if (child.branch != null) child.branch.Remove(child); // Add the child to this branch var newChildren = new List<ActionNode>(m_Children); newChildren.Add(child); m_Children = newChildren.ToArray(); child.branch = this; return true; } return false; }
/// <summary> /// Inserts a node in the nodes list at the supplied index. /// <param name = "index">The index to insert the behaviour.</param> /// <param name = "child">The node to be added to the list.</param> /// <returns>True if the node was added to the list; otherwise false.</returns> /// </summary> public override bool Insert (int index, ActionNode child) { if (child != null && index >= 0 && index <= m_Children.Length) { if (!Contains(child) && !Add(child)) return false; // Insert child var newChildren = new List<ActionNode>(m_Children); newChildren.Remove(child); newChildren.Insert(index, child); m_Children = newChildren.ToArray(); return true; } return false; }
// // Methods // public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent) { Enum @enum; if (Enum.IsDefined (this.attribute.GetEnumType (), property.value)) { @enum = (Enum)Enum.ToObject (this.attribute.GetEnumType (), property.value); } else { @enum = this.attribute.GetEnumValue (); } @enum=EditorGUILayout.EnumPopup (@enum); property.value= ((int)Convert.ChangeType (@enum, @enum.GetTypeCode ())); property.ApplyModifiedValue (); }
/// <summary> /// Draw the UnityEngine.Object using the objectType field. /// </summary> public override void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent) { // Object if (property.propertyType == NodePropertyType.UnityObject) { // Get the type path var attr = this.attribute as ObjectValueAttribute; string path = property.path; int lastDotIndex = path.LastIndexOf('.'); if (lastDotIndex > -1) path = path.Remove(lastDotIndex + 1, path.Length - lastDotIndex - 1); else path = string.Empty; // Get the property iterator NodePropertyIterator iterator = property.serializedNode.GetIterator(); // The type of the object string objectTypeAsString = string.Empty; // Get the object type as string if (iterator.Find(path + attr.typePropertyPath)) { SerializedNodeProperty typeProperty = iterator.current; objectTypeAsString = typeProperty.value as string ?? string.Empty; } // Get the object type System.Type objectType = !string.IsNullOrEmpty(objectTypeAsString) ? BehaviourMachine.TypeUtility.GetType(objectTypeAsString) ?? typeof(UnityEngine.Object) : typeof(UnityEngine.Object); // Used to detect if the gui control was changed EditorGUI.BeginChangeCheck(); // Draw the object gui control UnityEngine.Object newValue = EditorGUILayout.ObjectField(guiContent, property.value as UnityEngine.Object, objectType, !AssetDatabase.Contains(node.self)); // Value changed? if (EditorGUI.EndChangeCheck()) property.value = newValue; } // Not Object else EditorGUILayout.LabelField(guiContent, new GUIContent("Use ObjectValue with UnityEngine.Object.")); }
/// <summary> /// Draw the state pop-up. /// </summary> public override void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent) { // InternalStateBehaviour if (property.propertyType == NodePropertyType.UnityObject && property.type == typeof(InternalStateBehaviour)) { var rect = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.popup); var id = GUIUtility.GetControlID(FocusType.Passive); var popupRect = EditorGUI.PrefixLabel(rect, id, guiContent); var state = property.value as InternalStateBehaviour; // Set the pop-up color var oldGUIColor = GUI.color; if (state == null) GUI.color = Color.red; if (GUI.Button(popupRect, state != null ? state.stateName : "Null", EditorStyles.popup)) { // Get states var states = node.tree.states; // Create the pop-up menu var menu = new GenericMenu(); // Add null menu.AddItem(new GUIContent("Null"), state == null, delegate () {property.value = (InternalStateBehaviour)null;}); // Add states for (int i = 0; i < states.Count; i++) { InternalStateBehaviour currentState = states[i]; //setField = field != null ? new SetField(this.target, target, states[i], field, m_Tree) : new SetField(this.target, arrayField, index, states[i], m_Tree); menu.AddItem(new GUIContent(states[i].stateName), state == states[i], delegate () {property.value = currentState;}); } // Show menu menu.ShowAsContext(); } // Restore GUI.color GUI.color = oldGUIColor; } else EditorGUILayout.LabelField(guiContent, new GUIContent("Use TreeState with InternalStateBehaviour.")); }
/// <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(); }
/// <summary> /// Destroys the suplied node and its hierarchy from the tree. /// <param name="node">The node to be destroyed.</param> /// <returns>True if the node was successfully destroyed; false otherwise.</returns> /// </summary> public static bool DestroyNode (ActionNode node) { // Get the tree action state var actionState = node != null ? node.owner as InternalActionState : null; // Validate parameters if (actionState != null) { // Register Undo #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2 Undo.RegisterUndo(actionState, "Delete " + node.name); #else Undo.RecordObject(actionState, "Delete " + node.name); #endif // Removes node from actionState actionState.RemoveNode(node); // Saves actionState and marks dirty flag StateUtility.SetDirty(actionState); return true; } return false; }
// // Methods // public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent) { attribute.serializedObject = node; GUILayout.BeginHorizontal (); if (attribute.Min < attribute.Max) { if (attribute.HasEnableToggle) attribute.Enabled = GUILayout.Toggle (attribute.Enabled, property.label); if (attribute.Enabled) { GUILayout.Label (attribute.Min.ToString ()); _valueCurrent = GUILayout.HorizontalSlider (_valueCurrent, attribute.Min, attribute.Max); property.value = _valueCurrent; GUILayout.Label (attribute.Max.ToString ()); property.ApplyModifiedValue (); } } GUILayout.EndHorizontal (); }
/// <summary> /// Draw the TextArea. /// </summary> public override void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent) { // The text to display string text; // string if (property.propertyType == NodePropertyType.String) { // Get the text text = property.value as string ?? string.Empty; } // StringVar else if (property.propertyType == NodePropertyType.Variable && property.type == typeof(StringVar)) { // Get the text var stringVar = property.value as StringVar; if (stringVar != null) text = stringVar.Value as string ?? string.Empty; else text = string.Empty; } // Not supported else { EditorGUILayout.LabelField(guiContent, new GUIContent("Use TextAreaAttribute with string or StringVar.")); return; } // Create style? if (s_Styles == null) s_Styles = new NodeTextAreaDrawer.Styles(); // Get the text area var textAreaAttr = (NodeTextAreaAttribute) attribute; // Store the current content color Color contentColor = GUI.contentColor; // The text is empty? if (string.IsNullOrEmpty(text)) { text = textAreaAttr.hint; Color textColor = EditorStyles.label.normal.textColor; textColor.a = .5f; GUI.contentColor = textColor; } // Draw the text area. EditorGUI.BeginChangeCheck (); #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2 string value = EditorGUILayout.TextArea (text, s_Styles.textArea, GUILayout.Height(16f * textAreaAttr.lines)); #else string value = EditorGUILayout.TextArea (text, s_Styles.textArea, GUILayout.Height(EditorGUIUtility.singleLineHeight * textAreaAttr.lines)); #endif // Check for changes if (EditorGUI.EndChangeCheck ()) { if (property.propertyType == NodePropertyType.String) property.value = value; else { // Get the text var stringVar = property.value as StringVar; if (stringVar != null) { stringVar.Value = value; property.ValueChanged(); } } } // Restore content color GUI.contentColor = contentColor; }
/// <summary> /// Returns action and condition nodes in the supplied nodes; branch nodes are ignored but their hierarchy will be included. /// <returns>The actions and conditions in the supplied nodes.</returns> /// </summary> public static ActionNode[] GetActionsAndConditions (ActionNode[] nodes) { var actionCondition = new List<ActionNode>(); if (nodes != null) { for (int i = 0; i < nodes.Length; i++) { if (nodes[i] is BranchNode) { var branch = nodes[i] as BranchNode; actionCondition.AddRange(ActionStateUtility.GetActionsAndConditions(branch.children)); } else actionCondition.Add(nodes[i]); } } return actionCondition.ToArray(); }
// // Methods // /// <summary> /// Handles the onGUI event. /// </summary> /// <param name="property">Property.</param> /// <param name="node">Node.</param> /// <param name="guiContent">GUI content.</param> public override void OnGUI(SerializedNodeProperty property, ActionNode node, GUIContent guiContent) { //if (animatorSerialized == null || aniController == null) { if(aniController == null) { //!!! Serialization never serialized Animator cos its initialized in Reset after // NodePropertyIterator iter= property.serializedNode.GetIterator(); // iter.Find(attribute.animatorFieldName); // animatorSerialized=iter.current; // // if(animatorSerialized==null || animatorSerialized.value==null){ // Debug.LogError("AnimatorStateNodePropertyDrawer> No Animator component set on node parent GameObject"); // return; // } //runtimeContoller =( (Animator)animatorSerialized.value).runtimeAnimatorController; Animator animator = node.GetType ().GetField (attribute.animatorFieldName).GetValue (node) as Animator; RuntimeAnimatorController runtimeContoller; runtimeContoller = animator.runtimeAnimatorController; if (runtimeContoller is AnimatorOverrideController) aniController = ((AnimatorOverrideController)runtimeContoller).runtimeAnimatorController as UnityEditor.Animations.AnimatorController; else aniController = runtimeContoller as UnityEditor.Animations.AnimatorController; } animatorStateDisplayOptions = MecanimUtility.GetDisplayOptions (aniController); animatorStateValues = MecanimUtility.GetAnimatorStates (aniController); if(property.value!=null){ if(animatorStateValues.Length>0){ animatorStateSelectedPrev=animatorStateSelected=animatorStateValues.FirstOrDefault((itm)=>itm.nameHash==((ws.winx.unity.AnimatorState)property.value).nameHash); } } animatorStateSelected = EditorGUILayoutEx.CustomObjectPopup (guiContent, animatorStateSelected, animatorStateDisplayOptions, animatorStateValues);//,compare); //TODO try Begin/End Check if (animatorStateSelectedPrev != animatorStateSelected) { NodePropertyIterator iter = property.serializedNode.GetIterator (); iter.Find (attribute.layerIndexFieldName); SerializedNodeProperty layerIndexSerialized = iter.current; layerIndexSerialized.value = MecanimUtility.GetLayerIndex (aniController, animatorStateSelected); layerIndexSerialized.ApplyModifiedValue (); ws.winx.unity.AnimatorState state=property.value as ws.winx.unity.AnimatorState; if(state==null) state=ScriptableObject.CreateInstance<ws.winx.unity.AnimatorState>(); state.motion=animatorStateSelected.motion; state.nameHash=animatorStateSelected.nameHash; state.layer=(int)layerIndexSerialized.value; if(state.motion is UnityEditor.Animations.BlendTree){ BlendTree tree =(BlendTree)state.motion; int blendParamsNum= tree.GetRecursiveBlendParamCount(); state.blendParamsHashes=new int[blendParamsNum]; for(int i=0;i<blendParamsNum;i++) state.blendParamsHashes[i]=Animator.StringToHash(tree.GetRecursiveBlendParam(i)); }else{ state.blendParamsHashes=null; } //property.value=state; property.ValueChanged(); property.ApplyModifiedValue (); animatorStateSelectedPrev = animatorStateSelected; } if (animatorStateSelected.motion == null) Debug.LogError ("Selected state doesn't have Motion set"); }
public override bool CanAddNode(ActionNode child) { return(base.CanAddNode(child) && m_Child == null); }
/// <summary> /// Create the runtime lists of nodes. /// </summary> void CreateRuntimeListsOfNodes() { // iterator int i; // OnEnable Nodes var onEnableList = new List <ActionNode>(); for (i = 0; i < m_Nodes.Length; i++) { if (!(m_Nodes[i] is Update)) { onEnableList.Add(m_Nodes[i]); } else { break; } } if (onEnableList.Count > 0) { m_OnEnable = ActionNode.CreateInstance(typeof(OnEnable), gameObject, this) as OnEnable; m_OnEnable.SetChildren(onEnableList.ToArray()); } else { m_OnEnable = null; } // Update Nodes var updateList = new List <ActionNode>(); // FixedUpdate Nodes var fixedUpdateList = new List <ActionNode>(); // GUI Nodes var onGuiList = new List <ActionNode>(); for (int j = i + 1; j < m_Nodes.Length; j++) { // OnGUI if (m_Nodes[j] is IGUINode) { onGuiList.Add(m_Nodes[j]); } // FixedUpdate else if (m_Nodes[j] is IFixedUpdateNode) { fixedUpdateList.Add(m_Nodes[j]); } // Update else { updateList.Add(m_Nodes[j]); } } // FixedUpdate if (fixedUpdateList.Count > 0) { m_FixedUpdate = ActionNode.CreateInstance(typeof(FixedUpdate), gameObject, this) as FixedUpdate; // Call Reset if it's not in editor if (!Application.isEditor) { m_FixedUpdate.Reset(); } m_FixedUpdate.SetChildren(fixedUpdateList.ToArray()); } else { m_FixedUpdate = null; } // Update if (updateList.Count > 0) { m_Update = ActionNode.CreateInstance(typeof(Update), gameObject, this) as Update; // Call Reset if it's not in editor if (!Application.isEditor) { m_Update.Reset(); } m_Update.SetChildren(updateList.ToArray()); } else { m_Update = null; } // OnGUI if (onGuiList.Count > 0) { m_OnGUI = ActionNode.CreateInstance(typeof(OnGUI), gameObject, this) as OnGUI; // Call Reset if it's not in editor if (!Application.isEditor) { m_OnGUI.Reset(); } m_OnGUI.SetChildren(onGuiList.ToArray()); } else { m_OnGUI = null; } }
/// <summary> /// Returns the node index. /// <param name="node">The taget node.</param> /// <returns>The index of the supplied node.</returns> /// </summary> public int GetIndex(ActionNode node) { var nodes = GetNodes(); return(nodes != null?System.Array.IndexOf(nodes, node) : -1); }
/// <summary> /// Determines whether a node is a child of this branch. /// <param name = "child">The object to locate in the children list.</param> /// <returns>True if node is found in the children list; otherwise, false.</returns> /// </summary> public override bool Contains (ActionNode child) { for (int i = 0; i < m_Children.Length; i++) { if (m_Children[i] == child) return true; } return false; }
/// <summary> /// Determines whether a node is a child of this branch. /// <param name = "child">The node to locate in the children list.</param> /// <returns>True if node is found in the children list; otherwise, false.</returns> /// </summary> public override bool Contains(ActionNode child) { return(m_Child == child); }
public override bool CanAddNode (ActionNode child) { return base.CanAddNode(child) && m_Child == null; }
/// <summary> /// Destroys the suplied node and its hierarchy from the tree. /// <param name="node">The node to be destroyed.</param> /// <returns>True if the node was successfully destroyed; false otherwise.</returns> /// </summary> public static bool DestroyNode (ActionNode node) { // Validate parameters if (node != null && node.tree != null) { // Get parent and tree var tree = node.tree; var parent = node.branch; // Register Undo #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2 Undo.RegisterUndo(tree, "Delete " + node.name); #else Undo.RecordObject(tree, "Delete " + node.name); #endif // Removes node from parent if (parent != null) { parent.Remove(node); // Call OnValidate on the parent parent.OnValidate(); } // Removes node from tree tree.RemoveNode(node, true); // Saves tree and marks dirty flag StateUtility.SetDirty(tree); return true; } return false; }
/// <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; }
/// <summary> /// Removes a node from the branch. /// <param name = "child">The node to be removed from the list.</param> /// </summary> public override void Remove (ActionNode child) { if (m_Child == child) { m_Child = null; if (child != null && child.branch == this) child.branch = null; } }
/// <summary> /// Removes node from tree. /// <param name="node">The node to be removed.</param> /// </summary> public void RemoveNode (ActionNode node) { // It's not the Update node? if (!(node is Update)) { GetNodes(); // Remove node var nodes = new List<ActionNode>(m_Nodes); nodes.Remove(node); m_Nodes = nodes.ToArray(); this.HierarchyChanged(); } }
/// <summary> /// Returns the node index. /// <param name="node">The taget node.</param> /// <returns>The index of the supplied node.</returns> /// </summary> public int GetIndex (ActionNode node) { var nodes = GetNodes(); return nodes != null ? System.Array.IndexOf(nodes, node) : -1; }
/// <summary> /// Inserts a node in the branch list at the supplied index. /// <param name = "index">The index to insert the behaviour.</param> /// <param name = "child">The node to be added to the list.</param> /// <returns>True if the node was added to the list; otherwise false.</returns> /// </summary> public override bool Insert (int index, ActionNode child) { if (index != 0) return false; return Add (child); }
/// <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(); }
/// <summary> /// Removes the node from this branch. /// <param name = "child">The object to be removed from the list.</param> /// </summary> public override void Remove (ActionNode child) { if (Contains(child)) { // Remove child var newChildren = new List<ActionNode>(m_Children); newChildren.Remove(child); m_Children = newChildren.ToArray(); if (child != null && child.branch == this) child.branch = null; // Call ResetStatus if it is playing if (Application.isPlaying) child.ResetStatus(); } }
/// <summary> /// Reset the supplied node properties. /// <param name="node">The node to be reseted.</param> /// </summary> public static void ResetNode (ActionNode node) { // Get the owner as an Uniyt object var ownerUnityObj = node != null ? node.owner as UnityEngine.Object : null; // Validate parameters if (ownerUnityObj != null) { // Register Undo #if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2 Undo.RegisterUndo(ownerUnityObj, "Reset Node"); #else Undo.RecordObject(ownerUnityObj, "Reset Node"); #endif node.name = node.GetType().Name; node.Reset(); node.OnValidate(); StateUtility.SetDirty(node.owner); } }
/// <summary> /// Returns the node index. /// <param name="node">The taget node.</param> /// <returns>The index of the supplied node.</returns> /// </summary> public int GetIndex (ActionNode node) { var nodes = GetNodes (); return nodes != null ? nodes.IndexOf(node) : -1; }
/// <summary> /// Returns true if the supplied node can be add as child of the branch. /// <param name="newChild">The node to be tested if it can be a child of the branch.</param> /// <returns>True if the newChild can be a child of the branch; otherwise false.</returns> /// </summary> public virtual bool CanAddNode(ActionNode newChild) { return(newChild != null && newChild.tree == this.tree && !(newChild is FunctionNode) && (!(newChild is BranchNode) || !IsAncestor(newChild as BranchNode))); }
/// <summary> /// Returns the node index. /// <param name="node">The taget node.</param> /// <returns>The index of the supplied node.</returns> /// </summary> public int GetIndex(ActionNode node) { var nodes = GetNodes(); return(nodes != null?nodes.IndexOf(node) : -1); }
/// <summary> /// Determines whether a node is a child of this branch. /// <param name = "child">The object to locate in the children list.</param> /// <returns>True if node is found in the children list; otherwise, false.</returns> /// </summary> public abstract bool Contains(ActionNode child);
/// <summary> /// Removes the supplied node from this branch. /// <param name = "child">The object to be removed from the list.</param> /// </summary> public abstract void Remove(ActionNode child);
/// <summary> /// Inserts a node in the nodes list at the supplied index. /// <param name = "index">The index to insert the behaviour.</param> /// <param name = "child">The node to be added to the list.</param> /// <returns>True if the node was added to the list; otherwise false.</returns> /// </summary> public abstract bool Insert(int index, ActionNode child);
/// <summary> /// Adds the node to the branch nodes list. /// <param name = "child">The node to be added.</param> /// <returns>True if the node was added to the list; otherwise false.</returns> /// </summary> public abstract bool Add(ActionNode child);
/// <summary> /// Draw the property pop-up. /// </summary> public override void OnGUI (SerializedNodeProperty property, ActionNode node, GUIContent guiContent) { // String if (property.propertyType == NodePropertyType.String) { var rect = GUILayoutUtility.GetRect(GUIContent.none, EditorStyles.popup); var id = GUIUtility.GetControlID(FocusType.Passive); var popupRect = EditorGUI.PrefixLabel(rect, id, guiContent); var popupName = property.value as string ?? string.Empty; var propertyOrField = node as PropertyOrField; var oldGUIColor = GUI.color; if (propertyOrField.propertyType == null) GUI.color = Color.red; if (GUI.Button(popupRect, string.IsNullOrEmpty(popupName) ? "None" : popupName, EditorStyles.popup)) { var isSetProperty = propertyOrField is SetProperty; var members = FieldUtility.GetPublicMembers(propertyOrField.targetObject.ObjectType, null, false, isSetProperty, !isSetProperty); var menu = new GenericMenu(); // Add none menu.AddItem(new GUIContent("None"), string.IsNullOrEmpty(popupName), delegate () {property.value = string.Empty;}); // Add members for (int i = 0; i < members.Length; i++) { var memberName = members[i].Name; menu.AddItem(new GUIContent(memberName), popupName == memberName, delegate () {property.value = memberName;}); } menu.ShowAsContext(); } GUI.color = oldGUIColor; } // Not String else EditorGUILayout.LabelField(guiContent, new GUIContent("Use UnityObjectProperty with string.")); }