//////////////////////////////////////// ///////////GUI AND EDITOR STUFF///////// //////////////////////////////////////// #if UNITY_EDITOR protected override void OnTaskInspectorGUI(){ if (!Application.isPlaying && GUILayout.Button("Select Property")){ System.Action<MethodInfo> MethodSelected = (method)=> { functionWrapper = ReflectedFunctionWrapper.Create(method, blackboard); checkValue = BBParameter.CreateInstance( method.ReturnType, blackboard); comparison = CompareMethod.EqualTo; }; if (agent != null){ EditorUtils.ShowGameObjectMethodSelectionMenu(agent.gameObject, typeof(object), typeof(object), MethodSelected, 0, true, true); } else { var menu = new UnityEditor.GenericMenu(); foreach (var t in UserTypePrefs.GetPreferedTypesList(typeof(Component), true)) menu = EditorUtils.GetMethodSelectionMenu(t, typeof(object), typeof(object), MethodSelected, 0, true, true, menu); menu.ShowAsContext(); Event.current.Use(); } } if (targetMethod != null){ GUILayout.BeginVertical("box"); UnityEditor.EditorGUILayout.LabelField("Type", agentType.FriendlyName()); UnityEditor.EditorGUILayout.LabelField("Property", targetMethod.Name); GUILayout.EndVertical(); GUI.enabled = checkValue.varType == typeof(float) || checkValue.varType == typeof(int); comparison = (CompareMethod)UnityEditor.EditorGUILayout.EnumPopup("Comparison", comparison); GUI.enabled = true; EditorUtils.BBParameterField("Value", checkValue); } }
//////////////////////////////////////// ///////////GUI AND EDITOR STUFF///////// //////////////////////////////////////// protected override void OnTaskInspectorGUI() { if (!Application.isPlaying && GUILayout.Button("Select Field")){ System.Action<FieldInfo> FieldSelected = (field)=> { targetType = field.DeclaringType; fieldName = field.Name; checkValue = BBParameter.CreateInstance(field.FieldType, blackboard); comparison = CompareMethod.EqualTo; }; if (agent != null){ EditorUtils.ShowGameObjectFieldSelectionMenu(agent.gameObject, typeof(object), FieldSelected); } else { var menu = new UnityEditor.GenericMenu(); foreach (var t in UserTypePrefs.GetPreferedTypesList(typeof(Component), true)) menu = EditorUtils.GetFieldSelectionMenu(t, typeof(object), FieldSelected, menu); menu.ShowAsContext(); Event.current.Use(); } } if (agentType != null && !string.IsNullOrEmpty(fieldName)){ GUILayout.BeginVertical("box"); UnityEditor.EditorGUILayout.LabelField("Type", agentType.FriendlyName()); UnityEditor.EditorGUILayout.LabelField("Field", fieldName); GUILayout.EndVertical(); GUI.enabled = checkValue.varType == typeof(float) || checkValue.varType == typeof(int); comparison = (CompareMethod)UnityEditor.EditorGUILayout.EnumPopup("Comparison", comparison); GUI.enabled = true; EditorUtils.BBParameterField("Value", checkValue); } }
public static Task Create(Type type, ITaskSystem newOwnerSystem) { var newTask = (Task)Activator.CreateInstance(type); UndoUtility.RecordObject(newOwnerSystem.contextObject, "New Task"); BBParameter.SetBBFields(newTask, newOwnerSystem.blackboard); newTask.Validate(newOwnerSystem); newTask.OnCreate(newOwnerSystem); return(newTask); }
public static Task Create(Type type, ITaskSystem newOwnerSystem) { var newTask = (Task)Activator.CreateInstance(type); newOwnerSystem.RecordUndo("New Task"); newTask.SetOwnerSystem(newOwnerSystem); BBParameter.SetBBFields(newTask, newOwnerSystem.blackboard); newTask.OnValidate(newOwnerSystem); newTask.OnCreate(newOwnerSystem); return(newTask); }
//Duplicate the task for the target ITaskSystem virtual public Task Duplicate(ITaskSystem newOwnerSystem) { //Deep clone var newTask = JSONSerializer.Clone <Task>(this); newOwnerSystem.RecordUndo("Duplicate Task"); newTask.SetOwnerSystem(newOwnerSystem); BBParameter.SetBBFields(newTask, newOwnerSystem.blackboard); newTask.OnValidate(newOwnerSystem); return(newTask); }
protected override string OnInit() { leftChecker = agent.transform.Find("LeftChecker"); rightChecker = agent.transform.Find("RightChecker"); frontChecker = agent.transform.Find("FrontChecker"); backChecker = agent.transform.Find("BackChecker"); checkers.Add("left", leftChecker.value.GetComponent<SenseChecker>()); checkers.Add("right", rightChecker.value.GetComponent<SenseChecker>()); checkers.Add("forward", frontChecker.value.GetComponent<SenseChecker>()); checkers.Add("backward", backChecker.value.GetComponent<SenseChecker>()); return null; }
public static Task Create(Type type, ITaskSystem newOwnerSystem) { if (type.IsGenericTypeDefinition) { type = type.MakeGenericType(type.GetFirstGenericParameterConstraintType()); } var newTask = (Task)Activator.CreateInstance(type); UndoUtility.RecordObject(newOwnerSystem.contextObject, "New Task"); BBParameter.SetBBFields(newTask, newOwnerSystem.blackboard); newTask.Validate(newOwnerSystem); newTask.OnCreate(newOwnerSystem); return(newTask); }
///Create a new Task of type assigned to the target ITaskSystem public static Task Create(Type type, ITaskSystem newOwnerSystem) { var newTask = (Task)Activator.CreateInstance(type); #if UNITY_EDITOR if (!Application.isPlaying) { UnityEditor.Undo.RecordObject(newOwnerSystem.contextObject, "New Task"); } #endif newTask.SetOwnerSystem(newOwnerSystem); BBParameter.SetBBFields(newTask, newOwnerSystem.blackboard); newTask.OnValidate(newOwnerSystem); return(newTask); }
//Duplicate the task for the target ITaskSystem virtual public Task Duplicate(ITaskSystem newOwnerSystem) { //Deep clone var newTask = JSONSerializer.Deserialize <Task>(JSONSerializer.Serialize(typeof(Task), this)); #if UNITY_EDITOR if (!Application.isPlaying) { UnityEditor.Undo.RecordObject(newOwnerSystem.contextObject, "Duplicate Task"); } #endif newTask.SetOwnerSystem(newOwnerSystem); BBParameter.SetBBFields(newTask, newOwnerSystem.blackboard); newTask.OnValidate(newOwnerSystem); return(newTask); }
///Duplicate node alone assigned to the provided graph public Node Duplicate(Graph targetGraph) { if (targetGraph == null) { ParadoxNotion.Services.Logger.LogError("Can't duplicate a Node without providing a Target Graph", "NodeCanvas"); return(null); } //deep clone var newNode = JSONSerializer.Clone <Node>(this); if (targetGraph != null) { targetGraph.RecordUndo("Duplicate Node"); } targetGraph.allNodes.Add(newNode); newNode.inConnections.Clear(); newNode.outConnections.Clear(); if (targetGraph == this.graph) { newNode.position += new Vector2(50, 50); } newNode._UID = null; newNode.graph = targetGraph; BBParameter.SetBBFields(newNode, targetGraph.blackboard); //-- // var assignable = this as ITaskAssignable; // if ( assignable != null && assignable.task != null ) { // ( newNode as ITaskAssignable ).task = assignable.task.Duplicate(targetGraph); // } foreach (var task in Graph.GetTasksInElement(newNode)) { task.Validate(targetGraph); } //-- newNode.OnValidate(targetGraph); return(newNode); }
///Create a new Node of type and assigned to the provided graph. Use this for constructor public static Node Create(Graph targetGraph, System.Type nodeType, Vector2 pos) { if (targetGraph == null) { Logger.LogError("Can't Create a Node without providing a Target Graph", LogTag.GRAPH); return(null); } var newNode = (Node)System.Activator.CreateInstance(nodeType); UndoUtility.RecordObject(targetGraph, "Create Node"); newNode.graph = targetGraph; newNode.position = pos; BBParameter.SetBBFields(newNode, targetGraph.blackboard); newNode.Validate(targetGraph); newNode.OnCreate(targetGraph); UndoUtility.SetDirty(targetGraph); return(newNode); }
///Duplicate node alone assigned to the provided graph public Node Duplicate(Graph targetGraph) { if (targetGraph == null) { Debug.LogError("Can't duplicate a Node without providing a Target Graph"); return(null); } //deep clone var newNode = JSONSerializer.Deserialize <Node>(JSONSerializer.Serialize(typeof(Node), this)); #if UNITY_EDITOR if (!Application.isPlaying) { UnityEditor.Undo.RecordObject(targetGraph, "Duplicate"); } #endif targetGraph.allNodes.Add(newNode); newNode.inConnections.Clear(); newNode.outConnections.Clear(); if (targetGraph == this.graph) { newNode.nodePosition += new Vector2(50, 50); } newNode.graph = targetGraph; BBParameter.SetBBFields(newNode, targetGraph.blackboard); var assignable = this as ITaskAssignable; if (assignable != null && assignable.task != null) { (newNode as ITaskAssignable).task = assignable.task.Duplicate(targetGraph); } newNode.OnValidate(targetGraph); return(newNode); }
///Create a new Node of type and assigned to the provided graph. Use this for constructor public static Node Create(Graph targetGraph, System.Type nodeType, Vector2 pos) { if (targetGraph == null) { ParadoxNotion.Services.Logger.LogError("Can't Create a Node without providing a Target Graph", "NodeCanvas"); return(null); } var newNode = (Node)System.Activator.CreateInstance(nodeType); if (targetGraph != null) { targetGraph.RecordUndo("Create Node"); } newNode.graph = targetGraph; newNode.position = pos; BBParameter.SetBBFields(newNode, targetGraph.blackboard); newNode.OnValidate(targetGraph); newNode.OnCreate(targetGraph); return(newNode); }
///Create a new Node of type and assigned to the provided graph. Use this for constructor public static Node Create(Graph targetGraph, System.Type nodeType, Vector2 pos) { if (targetGraph == null) { Debug.LogError("Can't Create a Node without providing a Target Graph"); return(null); } var newNode = (Node)System.Activator.CreateInstance(nodeType); #if UNITY_EDITOR if (!Application.isPlaying) { UnityEditor.Undo.RecordObject(targetGraph, "Create Node"); } #endif newNode.graph = targetGraph; newNode.nodePosition = pos; BBParameter.SetBBFields(newNode, targetGraph.blackboard); newNode.OnValidate(targetGraph); return(newNode); }
///Duplicate node alone assigned to the provided graph public Node Duplicate(Graph targetGraph) { if (targetGraph == null) { Logger.LogError("Can't duplicate a Node without providing a Target Graph", LogTag.GRAPH); return(null); } //deep clone var newNode = JSONSerializer.Clone <Node>(this); UndoUtility.RecordObject(targetGraph, "Duplicate Node"); targetGraph.allNodes.Add(newNode); newNode.inConnections.Clear(); newNode.outConnections.Clear(); if (targetGraph == this.graph) { newNode.position += new Vector2(50, 50); } newNode._UID = null; newNode.graph = targetGraph; BBParameter.SetBBFields(newNode, targetGraph.blackboard); foreach (var task in Graph.GetTasksInElement(newNode)) { task.Validate(targetGraph); } //-- newNode.Validate(targetGraph); UndoUtility.SetDirty(targetGraph); return(newNode); }
//a special object field for the BBParameter class to let user choose either a real value or enter a string to read data from a Blackboard public static BBParameter BBParameterField(string prefix, BBParameter bbParam, bool blackboardOnly = false, MemberInfo member = null) { if (bbParam == null){ EditorGUILayout.LabelField(prefix, "Non Set Variable"); return null; } GUILayout.BeginVertical(); GUILayout.BeginHorizontal(); //override if we have a memeber info if (member != null){ blackboardOnly = member.RTGetAttribute<BlackboardOnlyAttribute>(false) != null; } //Direct assignement if (!blackboardOnly && !bbParam.useBlackboard){ GUILayout.BeginVertical(); bbParam.value = GenericField(prefix, bbParam.value, bbParam.varType, member); GUILayout.EndVertical(); //Dropdown variable selection } else { GUI.color = new Color(0.9f,0.9f,1f,1f); var varNames = new List<string>(); //Local if (bbParam.bb != null){ varNames.AddRange(bbParam.bb.GetVariableNames(bbParam.varType)); } //Seperator varNames.Add("/"); //Globals foreach (var globalBB in GlobalBlackboard.allGlobals) { var globalVars = globalBB.GetVariableNames(bbParam.varType); if (globalVars.Length == 0){ varNames.Add(globalBB.name + "/"); } for (var i = 0; i < globalVars.Length; i++){ globalVars[i] = globalBB.name + "/" + globalVars[i]; } varNames.AddRange( globalVars ); } //Dynamic varNames.Add("(DynamicVar)"); //New if (bbParam.bb != null){ varNames.Add("(Create New)"); } var isDynamic = !string.IsNullOrEmpty(bbParam.name) && !varNames.Contains(bbParam.name); if (!isDynamic){ bbParam.name = StringPopup(prefix, bbParam.name, varNames, false, true); if (bbParam.name == "(DynamicVar)"){ bbParam.name = "_"; } if (bbParam.bb != null && bbParam.name == "(Create New)"){ if (bbParam.bb.AddVariable(prefix, bbParam.varType) != null){ bbParam.name = prefix; } else { bbParam.name = null; } } } else { bbParam.name = EditorGUILayout.TextField(prefix + " (" + bbParam.varType.FriendlyName() + ")", bbParam.name); } } GUI.color = Color.white; GUI.backgroundColor = Color.white; if (!blackboardOnly){ bbParam.useBlackboard = EditorGUILayout.Toggle(bbParam.useBlackboard, EditorStyles.radioButton, GUILayout.Width(18)); } GUILayout.EndHorizontal(); if (bbParam.isNone || bbParam.bb == null){ GUI.backgroundColor = new Color(0.8f,0.8f,1f,0.5f); GUI.color = new Color(1f,1f,1f,0.5f); GUILayout.BeginVertical("textfield"); var info = string.Empty; if (bbParam.bb == null){ info = "<i>No current Blackboard reference</i>"; } else if (bbParam.isNone){ info = "Select '" + bbParam.varType.FriendlyName() + "' Assignable Blackboard Variable"; } GUILayout.Label(info); GUILayout.EndVertical(); GUILayout.Space(2); } GUILayout.EndVertical(); GUI.backgroundColor = Color.white; GUI.color = Color.white; return bbParam; }
///Get a list of BBParameter names used by the target element object. public static List <string> GetUsedParameterNamesOfTarget(object target) { var result = new List <string>(); if (target == null) { return(result); } result.AddRange(BBParameter.GetObjectBBParameters(target).Select(p => p.name)); var task = target as Task; if (task != null) { result.AddRange(BBParameter.GetObjectBBParameters(task).Select(p => p.name)); if (!string.IsNullOrEmpty(task.overrideAgentParameterName)) { result.Add(task.overrideAgentParameterName); } } var taskActionList = target as ActionList; if (taskActionList != null) { for (var i = 0; i < taskActionList.actions.Count; i++) { var t = taskActionList.actions[i]; result.AddRange(BBParameter.GetObjectBBParameters(t).Select(p => p.name)); if (!string.IsNullOrEmpty(t.overrideAgentParameterName)) { result.Add(t.overrideAgentParameterName); } } } var taskConditionList = target as ConditionList; if (taskConditionList != null) { for (var i = 0; i < taskConditionList.conditions.Count; i++) { var t = taskConditionList.conditions[i]; result.AddRange(BBParameter.GetObjectBBParameters(t).Select(p => p.name)); if (!string.IsNullOrEmpty(t.overrideAgentParameterName)) { result.Add(t.overrideAgentParameterName); } } } var subContainer = target as ISubTasksContainer; if (subContainer != null) { var subTasks = subContainer.GetSubTasks(); for (var i = 0; i < subTasks.Length; i++) { result.AddRange(GetUsedParameterNamesOfTarget(subTasks[i])); } } var assignable = target as ITaskAssignable; if (assignable != null && assignable.task != null) { result.AddRange(GetUsedParameterNamesOfTarget(assignable.task)); } return(result); }
protected bool NodeToXml(Node node, XmlElement xmlParentElement) { bool bSuccess = true; var enumConnection = node.outConnections.GetEnumerator(); XmlElement xmlNode = null; if (typeof(Sequencer).IsInstanceOfType(node)) { xmlNode = xmlParentElement.OwnerDocument.CreateElement("sequencer"); xmlNode.SetAttribute("name", "sequencer" + node.ID); } else if (typeof(Selector).IsInstanceOfType(node)) { xmlNode = xmlParentElement.OwnerDocument.CreateElement("selector"); xmlNode.SetAttribute("name", "selector" + node.ID); } else if (typeof(Inverter).IsInstanceOfType(node)) { xmlNode = xmlParentElement.OwnerDocument.CreateElement("inverter"); xmlNode.SetAttribute("name", "inverter" + node.ID); } else if (typeof(ITaskAssignable).IsInstanceOfType(node)) { xmlNode = xmlParentElement.OwnerDocument.CreateElement("action"); Task task = (node as ITaskAssignable).task; if (task != null) { string typeName = task.GetType().FriendlyName(); xmlNode.SetAttribute("classname", typeName); xmlNode.SetAttribute("name", typeName); FieldInfo[] fields = task.GetType().GetFields(); foreach (FieldInfo field in fields) { object fieldVar = field.GetValue(task); if (fieldVar.GetType().IsSubclassOf(typeof(BBParameter))) { BBParameter param = fieldVar as BBParameter; string varName = field.Name; if (field.IsDefined(typeof(ExportNameAttribute), false)) { object[] attrs = field.GetCustomAttributes(typeof(ExportNameAttribute), false); if (attrs != null) { ExportNameAttribute attr = attrs.FirstOrDefault() as ExportNameAttribute; if (attr != null) { varName = attr.exportName; } } } XmlElement xmlParam = xmlParentElement.OwnerDocument.CreateElement("param"); xmlParam.SetAttribute("name", varName); xmlParam.SetAttribute("type", Variable.GetTypeName(param.varType)); if (param.useBlackboard) { xmlParam.SetAttribute("ref", param.name); } else { string valueStr = null; if (param.varType.IsEnum) { valueStr = System.Convert.ToString((int)param.value); } else { valueStr = System.Convert.ToString(param.value).ToLower(); } xmlParam.SetAttribute("value", valueStr); } xmlNode.AppendChild(xmlParam); } } } else { bSuccess = false; Debug.LogError("ActionNode without Action, Condition node without Condition! " + node.name); } } else if (typeof(SubTree).IsInstanceOfType(node)) { //todo 递归插入subtree node SubTree st = node as SubTree; st.Init(); if (st.subTree) { NodeToXml(st.subTree.primeNode, xmlParentElement); } else { Debug.LogError("can not find the subtree : id = " + node.ID); } } else if (typeof(ConditionNode).IsInstanceOfType(node)) { //xmlNode = xmlParentElement.OwnerDocument.CreateElement("condition"); bSuccess = false; Debug.LogError("Unsupported type used: " + node.name); } else { bSuccess = false; Debug.LogError("Unsupported type used: " + node.name); } if (xmlNode != null) { xmlNode.SetAttribute("id", System.Convert.ToString(node.ID)); while (enumConnection.MoveNext() && bSuccess) { bSuccess = NodeToXml(enumConnection.Current.targetNode, xmlNode); } if (bSuccess) { xmlParentElement.AppendChild(xmlNode); } } return(bSuccess); }
//////////////////////////////////////// ///////////GUI AND EDITOR STUFF///////// //////////////////////////////////////// #if UNITY_EDITOR protected override void OnTaskInspectorGUI(){ DrawDefaultInspector(); if (GUILayout.Button("Select Type")) EditorUtils.ShowPreferedTypesSelectionMenu(typeof(object), (t)=> {newValue = BBParameter.CreateInstance(t, blackboard);} ); }
//a special object field for the BBParameter class to let user choose either a real value or enter a string to read data from a Blackboard public static BBParameter BBParameterField(string prefix, BBParameter bbParam, bool blackboardOnly = false, MemberInfo member = null) { if (bbParam == null){ EditorGUILayout.LabelField(prefix, "Non Set Variable"); return null; } GUILayout.BeginVertical(); GUILayout.BeginHorizontal(); //override if we have a memeber info if (member != null){ blackboardOnly = member.RTGetAttribute<BlackboardOnlyAttribute>(false) != null; } //Direct assignement if (!blackboardOnly && !bbParam.useBlackboard){ bbParam.value = GenericField(prefix, bbParam.value, bbParam.varType, member); //Dropdown variable selection } else { GUI.color = new Color(0.9f,0.9f,1f,1f); var varNames = new List<string>(); //Local if (bbParam.bb != null) varNames.AddRange(bbParam.bb.GetVariableNames(bbParam.varType)); //Globals foreach (var globalBB in GlobalBlackboard.allGlobals.Where(globalBB => globalBB != bbParam.bb)) { varNames.Add(globalBB.name + "/"); var globalVars = globalBB.GetVariableNames(bbParam.varType); for (var i = 0; i < globalVars.Length; i++) globalVars[i] = globalBB.name + "/" + globalVars[i]; varNames.AddRange( globalVars ); } //Dynamic varNames.Add("(DynamicVar)"); var isDynamic = !string.IsNullOrEmpty(bbParam.name) && !varNames.Contains(bbParam.name); if (!isDynamic){ bbParam.name = StringPopup(prefix, bbParam.name, varNames, false, true); if (bbParam.name == "(DynamicVar)"){ bbParam.name = "_"; } } else { bbParam.name = EditorGUILayout.TextField(prefix + " (" + bbParam.varType.FriendlyName() + ")", bbParam.name); } } GUI.color = Color.white; GUI.backgroundColor = Color.white; if (!blackboardOnly) bbParam.useBlackboard = EditorGUILayout.Toggle(bbParam.useBlackboard, EditorStyles.radioButton, GUILayout.Width(18)); GUILayout.EndHorizontal(); if (bbParam.useBlackboard && string.IsNullOrEmpty(bbParam.name)){ GUI.backgroundColor = new Color(0.8f,0.8f,1f,0.5f); GUI.color = new Color(1f,1f,1f,0.5f); GUILayout.BeginVertical("textfield"); GUILayout.BeginHorizontal(); if ( bbParam.bb != null && bbParam.varType != typeof(object) ){ if (GUILayout.Button("<b>+</b>", (GUIStyle)"label", GUILayout.Width(20) )){ if (bbParam.bb.AddVariable(prefix, bbParam.varType) != null) bbParam.name = prefix; } EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.ArrowPlus); } if (bbParam.bb != null){ GUILayout.Label("Select a '" + bbParam.varType.FriendlyName() + "' Blackboard Variable"); } else { GUILayout.Label("<i>No current Blackboard reference</i>"); } GUILayout.EndHorizontal(); GUILayout.EndVertical(); GUILayout.Space(2); } GUILayout.EndVertical(); GUI.backgroundColor = Color.white; GUI.color = Color.white; return bbParam; }
protected override void OnNodeInspectorGUI() { if (outConnections.Count == 0){ GUILayout.Label("Make some connections first"); return; } var total = GetTotal(); for (var i = 0; i < childWeights.Count; i++){ GUILayout.BeginHorizontal(); childWeights[i] = (BBParameter<float>)EditorUtils.BBParameterField("Weight", childWeights[i]); GUILayout.Label( Mathf.Round( (childWeights[i].value/total) * 100 ) + "%", GUILayout.Width(38)); GUILayout.EndHorizontal(); } GUILayout.Space(5); GUILayout.BeginHorizontal(); failChance = (BBParameter<float>)EditorUtils.BBParameterField("Direct Failure Chance", failChance); GUILayout.Label( Mathf.Round( (failChance.value/total) * 100 ) + "%", GUILayout.Width(38)); GUILayout.EndHorizontal(); }
protected override void OnNodeInspectorGUI() { repeaterMode = (RepeaterMode)UnityEditor.EditorGUILayout.EnumPopup("Repeat Type", repeaterMode); if (repeaterMode == RepeaterMode.RepeatTimes){ repeatTimes = (BBParameter<int>)EditorUtils.BBParameterField("Repeat Times", repeatTimes); } else if (repeaterMode == RepeaterMode.RepeatUntil){ repeatUntilStatus = (RepeatUntilStatus)UnityEditor.EditorGUILayout.EnumPopup("Repeat Until", repeatUntilStatus); } }
///Validate the task in respects to the target ITaskSystem public void Validate(ITaskSystem ownerSystem) { SetOwnerSystem(ownerSystem); BBParameter.SetBBFields(this, ownerSystem.blackboard); OnValidate(ownerSystem); }
protected override void OnNodeInspectorGUI() { filterMode = (FilterMode)UnityEditor.EditorGUILayout.EnumPopup("Mode", filterMode); if (filterMode == FilterMode.CoolDown){ coolDownTime = (BBParameter<float>)EditorUtils.BBParameterField("CoolDown Time", coolDownTime); } else if (filterMode == FilterMode.LimitNumberOfTimes){ maxCount = (BBParameter<int>)EditorUtils.BBParameterField("Max Times", maxCount); } inactiveWhenLimited = UnityEditor.EditorGUILayout.Toggle("Inactive When Limited", inactiveWhenLimited); }
protected override void OnNodeInspectorGUI() { selectionMode = (CaseSelectionMode)UnityEditor.EditorGUILayout.EnumPopup("Selection Mode", selectionMode); if (selectionMode == CaseSelectionMode.IndexBased) { intCase = (BBParameter<int>)EditorUtils.BBParameterField("Int", intCase); outOfRangeMode = (OutOfRangeMode)UnityEditor.EditorGUILayout.EnumPopup("When Out Of Range", outOfRangeMode); } else { enumCase = (BBObjectParameter)EditorUtils.BBParameterField("Enum", enumCase, true); if (enumCase.value != null){ GUILayout.BeginVertical("box"); foreach (var s in System.Enum.GetNames(enumCase.value.GetType()) ) GUILayout.Label(s); GUILayout.EndVertical(); } } }