////////////////////////////////////////
///////////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();
}
}
}
