private List <NodeValue> GetNodeList(JsonData data)
{
List <NodeValue> nodeList = new List <NodeValue>();
foreach (JsonData item in data)
{
NodeValue nodeValue = new NodeValue();
nodeValue.id = int.Parse(item["id"].ToString());
nodeValue.isRootNode = bool.Parse(item["isRootNode"].ToString());
nodeValue.NodeType = int.Parse(item["NodeType"].ToString());
nodeValue.parentNodeID = int.Parse(item["parentNodeID"].ToString());
JsonData childNodeList = item["childNodeList"];
nodeValue.childNodeList = GetChildIdList(childNodeList);
nodeValue.repeatTimes = int.Parse(item["repeatTimes"].ToString());
nodeValue.nodeName = item["nodeName"].ToString();
nodeValue.identification = int.Parse(item["identification"].ToString());
nodeValue.descript = item["descript"].ToString();
JsonData conditionGroupList = item["conditionGroupList"];
nodeValue.conditionGroupList = GetConditionGroupList(conditionGroupList);
JsonData parameterList = item["parameterList"];
nodeValue.parameterList = GetParameterList(parameterList);
JsonData position = item["position"];
nodeValue.position = GetPosition(position);
nodeList.Add(nodeValue);
}
return(nodeList);
}
public void OnGUI()
{
NodeValue currentNode = _behaviorDrawModel.GetCurrentSelectNode();
List <NodeValue> nodeList = _behaviorDrawModel.GetDrawNode();
_behaviorDrawView.Draw(currentNode, nodeList);
}
// 检测子节点是否包含圈
private void CheckCircle(BehaviorTreeData treeData, int id)
{
HashSet <int> hash = new HashSet <int>();
Queue <int> queue = new Queue <int>();
queue.Enqueue(id);
while (queue.Count > 0)
{
id = queue.Dequeue();
NodeValue nodeValue = treeData.nodeList.Find((a) => {
return(a.id == id);
});
if (null == nodeValue || nodeValue.childNodeList.Count <= 0)
{
continue;
}
foreach (var childId in nodeValue.childNodeList)
{
if (hash.Contains(childId))
{
Debug.LogError(treeData.fileName + " NodeValue:" + childId + " Has multiple parent");
break;
}
else
{
hash.Add(childId);
queue.Enqueue(childId);
}
}
}
}
private void ResetScrollPos(List <NodeValue> nodeList)
{
if (nodeList.Count <= 0)
{
return;
}
NodeValue rightmostNode = null;
NodeValue bottomNode = null;
for (int i = 0; i < nodeList.Count; ++i)
{
NodeValue nodeValue = nodeList[i];
if (rightmostNode == null || (nodeValue.position.x > rightmostNode.position.x))
{
rightmostNode = nodeValue;
}
if (bottomNode == null || (nodeValue.position.y > bottomNode.position.y))
{
bottomNode = nodeValue;
}
}
if ((rightmostNode.position.x + rightmostNode.position.width) > contentRect.width)
{
contentRect.width = rightmostNode.position.x + rightmostNode.position.width + 50;
}
if ((bottomNode.position.y + bottomNode.position.height) > contentRect.height)
{
contentRect.height = bottomNode.position.y + +bottomNode.position.height + 50;
}
}
public static List <NodeValue> FindChild(BehaviorTreeData treeData, int nodeId)
{
List <NodeValue> nodeList = new List <NodeValue>();
Queue <int> queue = new Queue <int>();
queue.Enqueue(nodeId);
while (queue.Count > 0)
{
int id = queue.Dequeue();
NodeValue nodeValue = GetNode(treeData, id);
if (null == nodeValue)
{
continue;
}
if (id != nodeId)
{
nodeList.Add(nodeValue);
}
foreach (var node in nodeValue.childNodeList)
{
queue.Enqueue(node);
}
}
return(nodeList);
}
private string GetNodeName(NodeValue nodeValue)
{
int nodeIndex = EnumNames.GetEnumIndex <NODE_TYPE>((NODE_TYPE)nodeValue.NodeType);
string name = EnumNames.GetEnumName <NODE_TYPE>(nodeIndex);
return(string.Format("{0}_{1}", name, nodeValue.id));
}
private List <NodeValue> GetSubTreeNode(int currentOpenSubTreeId)
{
List <NodeValue> nodeList = new List <NodeValue>();
NodeValue subTreeNode = BehaviorDataController.Instance.GetNode(currentOpenSubTreeId);
if (null == subTreeNode)
{
return(nodeList);
}
if (subTreeNode.subTreeType == (int)SUB_TREE_TYPE.NORMAL)
{
List <NodeValue> allNodeList = GetNodeList();
for (int i = 0; i < allNodeList.Count; ++i)
{
NodeValue nodeValue = allNodeList[i];
if (currentOpenSubTreeId >= 0 && nodeValue.parentSubTreeNodeId == currentOpenSubTreeId)
{
nodeList.Add(nodeValue);
}
}
}
else if (subTreeNode.subTreeType == (int)SUB_TREE_TYPE.CONFIG)
{
ConfigFileLoad configFileLoad = new ConfigFileLoad();
BehaviorTreeData data = configFileLoad.ReadFile(subTreeNode.subTreeConfig, false);
if (null != data)
{
nodeList.AddRange(data.nodeList);
}
}
return(nodeList);
}
private void DrawAddParameter(NodeValue nodeValue)
{
GUI.enabled = !BehaviorManager.Instance.CurrentOpenConfigSubTree();
if (GUILayout.Button("添加条件"))
{
if (BehaviorManager.Instance.BehaviorTreeData.parameterList.Count <= 0)
{
string msg = "没有参数可添加，请先添加参数";
if (TreeNodeWindow.window != null)
{
TreeNodeWindow.window.ShowNotification(msg);
}
}
else
{
if (null != BehaviorManager.behaviorNodeParameter)
{
BehaviorParameter behaviorParameter = BehaviorManager.Instance.BehaviorTreeData.parameterList[0];
BehaviorManager.behaviorNodeParameter(nodeValue.id, behaviorParameter, true);
}
}
}
GUI.enabled = true;
}
// 删除节点
public void DeleteNode(int nodeId)
{
List <NodeValue> NodeList = BehaviorDataController.Instance.NodeList;
for (int i = 0; i < NodeList.Count; ++i)
{
NodeValue nodeValue = NodeList[i];
if (nodeValue.id != nodeId)
{
continue;
}
RemoveParentNode(nodeValue.id);
for (int j = 0; j < nodeValue.childNodeList.Count; ++j)
{
int childId = nodeValue.childNodeList[j];
NodeValue childNode = BehaviorDataController.Instance.GetNode(childId);
childNode.parentNodeID = -1;
}
if (nodeValue.NodeType == (int)NODE_TYPE.SUB_TREE)
{
DeleteSubTreeChild(nodeValue.id);
}
NodeList.Remove(nodeValue);
break;
}
}
private void EntryNode(NodeValue nodeValue)
{
if (nodeValue.NodeType == (int)NODE_TYPE.CONDITION ||
nodeValue.NodeType == (int)NODE_TYPE.ACTION ||
nodeValue.NodeType == (int)NODE_TYPE.SUB_TREE
)
{
return;
}
if (nodeValue.parentSubTreeNodeId < 0)
{
bool oldValue = nodeValue.isRootNode;
nodeValue.isRootNode = EditorGUILayout.Toggle(new GUIContent("根节点"), nodeValue.isRootNode /*, GUILayout.Width(50)*/);
if (nodeValue.isRootNode && oldValue != nodeValue.isRootNode)
{
if (null != BehaviorManager.behaviorChangeRootNode)
{
BehaviorManager.behaviorChangeRootNode(nodeValue.id);
}
}
}
else
{
bool oldValue = nodeValue.subTreeEntry;
nodeValue.subTreeEntry = EditorGUILayout.Toggle(new GUIContent("子树入口节点"), nodeValue.subTreeEntry /*, GUILayout.Width(50)*/);
if (nodeValue.subTreeEntry && oldValue != nodeValue.subTreeEntry)
{
if (null != BehaviorManager.behaviorChangeSubTreeEntryNode)
{
BehaviorManager.behaviorChangeSubTreeEntryNode(nodeValue.parentSubTreeNodeId, nodeValue.id);
}
}
}
}
private static void CheckChildID(BehaviorTreeData treeData, int id)
{
NodeValue nodeValue = treeData.nodeList.Find((a) => {
return(a.id == id);
});
if (null == nodeValue || nodeValue.childNodeList.Count <= 0)
{
return;
}
HashSet <int> hash = new HashSet <int>();
for (int i = nodeValue.childNodeList.Count - 1; i >= 0; --i)
{
int childId = nodeValue.childNodeList[i];
if (hash.Contains(childId))
{
nodeValue.childNodeList.RemoveAt(i);
Debug.LogError(treeData.fileName + " NodeValue:" + nodeValue.id + " Has Same Child:" + childId);
}
else
{
hash.Add(childId);
}
CheckChildID(treeData, childId);
}
}
private ConditionGroup DrawConditionGroup(NodeValue nodeValue)
{
ConditionGroup conditionGroup = null;
if (nodeValue.NodeType != (int)NODE_TYPE.CONDITION)
{
return(conditionGroup);
}
EditorGUILayout.BeginVertical("box");
{
conditionGroup = BehaviorConditionGroup.DrawTransitionGroup(nodeValue);
GUI.enabled = !BehaviorDataController.Instance.CurrentOpenConfigSubTree();
if (GUILayout.Button("添加组"))
{
DataNodeHandler dataNodeHandler = new DataNodeHandler();
dataNodeHandler.NodeAddConditionGroup(nodeValue.id);
}
GUI.enabled = true;
}
EditorGUILayout.EndVertical();
return(conditionGroup);
}
private AbstractNode AnalysisNode(NodeValue nodeValue, IConditionCheck iConditionCheck)
{
AbstractNode nodeBase = BehaviorConfigNode.Instance.GetNode(nodeValue.identificationName);
if (nodeValue.NodeType == (int)NODE_TYPE.CONDITION) // 条件节点
{
NodeCondition condition = (NodeCondition)nodeBase;
condition.SetData(nodeValue.parameterList, nodeValue.conditionGroupList);
condition.SetConditionCheck(iConditionCheck);
}
else if (nodeValue.NodeType == (int)NODE_TYPE.ACTION)
{
NodeAction action = (NodeAction)nodeBase;
action.SetParameters(nodeValue.parameterList);
}
else if (nodeValue.NodeType == (int)NODE_TYPE.IF_JUDEG_PARALLEL || nodeValue.NodeType == (int)NODE_TYPE.IF_JUDEG_SEQUENCE)
{
NodeIfJudge ifJudge = (NodeIfJudge)nodeBase;
ifJudge.SetData(nodeValue.ifJudgeDataList);
ifJudge.SetDefaultResult((ResultType)nodeValue.defaultResult);
}
else if (nodeValue.NodeType == (int)NODE_TYPE.DECORATOR_REPEAT)
{
NodeDecoratorRepeat repeat = (NodeDecoratorRepeat)nodeBase;
repeat.SetRepeatCount(nodeValue.repeatTimes);
}
return(nodeBase);
}
public void NodeAddConditionGroup(int nodeId)
{
NodeValue nodeValue = BehaviorDataController.Instance.GetNode(nodeId);
if (null == nodeValue)
{
return;
}
for (int i = 0; i < nodeValue.conditionGroupList.Count + 1; ++i)
{
ConditionGroup conditionGroup = nodeValue.conditionGroupList.Find(a => a.index == i);
if (null == conditionGroup)
{
conditionGroup = new ConditionGroup();
conditionGroup.index = i;
nodeValue.conditionGroupList.Add(conditionGroup);
break;
}
}
if (nodeValue.conditionGroupList.Count <= 0)
{
ConditionGroup conditionGroup = new ConditionGroup();
conditionGroup.index = 0;
nodeValue.conditionGroupList.Add(conditionGroup);
}
}
private NodeIfJudge GetIfJudge(NodeValue nodeValue)
{
NodeIfJudge ifJudge = new NodeIfJudge();
ifJudge.SetData(nodeValue.ifJudgeDataList);
return(ifJudge);
}
public void DebugNodeParentInfo(int nodeId)
{
if (nodeId < 0)
{
return;
}
StringBuilder sb = new StringBuilder();
NodeValue nodeValue = BehaviorDataController.Instance.GetNode(nodeId);
while (null != nodeValue)
{
sb.AppendFormat("{0}->", nodeValue.id);
NodeValue parentNode = null;
if (nodeValue.parentNodeID < 0 && nodeValue.parentSubTreeNodeId > 0)
{
parentNode = BehaviorDataController.Instance.GetNode(nodeValue.parentSubTreeNodeId);
}
else
{
parentNode = BehaviorDataController.Instance.GetNode(nodeValue.parentNodeID);
}
nodeValue = parentNode;
}
UnityEngine.Debug.LogError("ParentInfo:" + sb.ToString());
}
public NodeDecoratorRepeat GetRepeat(NodeValue nodeValue)
{
NodeDecoratorRepeat repeat = new NodeDecoratorRepeat();
repeat.SetRepeatCount(nodeValue.repeatTimes);
return(repeat);
}
public string[] GetOptionArr(Dictionary <string, int> dic)
{
List <string> optionList = new List <string>();
optionList.Add("Base");
dic["Base"] = -1;
if (BehaviorDataController.Instance.CurrentOpenSubTree >= 0)
{
int nodeId = BehaviorDataController.Instance.CurrentOpenSubTree;
NodeValue nodeValue = BehaviorDataController.Instance.GetNode(nodeId);
while (null != nodeValue && nodeValue.NodeType == (int)NODE_TYPE.SUB_TREE)
{
string name = GetNodeName(nodeValue);
optionList.Insert(1, name);
dic[name] = nodeValue.id;
if (nodeValue.parentSubTreeNodeId <= 0)
{
break;
}
nodeValue = BehaviorDataController.Instance.GetNode(nodeValue.parentSubTreeNodeId);
}
}
return(optionList.ToArray());
}
public void RemoveParentNode(int nodeId)
{
NodeValue nodeValue = BehaviorDataController.Instance.GetNode(nodeId);
if (nodeValue.parentNodeID < 0)
{
return;
}
NodeValue parentNode = BehaviorDataController.Instance.GetNode(nodeValue.parentNodeID);
if (null != parentNode)
{
for (int i = 0; i < parentNode.childNodeList.Count; ++i)
{
int childId = parentNode.childNodeList[i];
NodeValue childNode = BehaviorDataController.Instance.GetNode(childId);
if (childNode.id == nodeValue.id)
{
parentNode.childNodeList.RemoveAt(i);
break;
}
}
}
nodeValue.parentNodeID = -1;
}
public NodeAction GetAction(NodeValue nodeValue)
{
NodeAction action = (NodeAction)CustomNode.Instance.GetNode(nodeValue.identification);
action.SetParameters(nodeValue.parameterList);
return(action);
}
private ConditionGroup DrawConditionGroup(NodeValue nodeValue)
{
ConditionGroup conditionGroup = null;
if (nodeValue.NodeType != (int)NODE_TYPE.CONDITION)
{
return(conditionGroup);
}
EditorGUILayout.BeginVertical("box");
{
conditionGroup = BehaviorConditionGroup.DrawTransitionGroup(nodeValue);
if (GUILayout.Button("添加组"))
{
if (null != BehaviorManager.behaviorAddDelConditionGroup)
{
BehaviorManager.behaviorAddDelConditionGroup(nodeValue.id, -1, true);
}
}
}
EditorGUILayout.EndVertical();
return(conditionGroup);
}
public NodeCondition GetCondition(NodeValue nodeValue, IConditionCheck iConditionCheck)
{
NodeCondition condition = (NodeCondition)CustomNode.Instance.GetNode(nodeValue.identification);
condition.SetData(nodeValue.parameterList, nodeValue.conditionGroupList);
condition.SetConditionCheck(iConditionCheck);
return(condition);
}
public static NodeValue GetNode(BehaviorTreeData treeData, int nodeId)
{
NodeValue nodeValue = treeData.nodeList.Find((a) => {
return(a.id == nodeId);
});
return(nodeValue);
}
private NodeBase AnalysisNode(int entityId, long aiFunction, BehaviorTreeData data, int nodeId, IConditionCheck iConditionCheck, Action <int> InvalidSubTreeCallBack)
{
NodeValue nodeValue = null;
if (!data.nodeDic.TryGetValue(nodeId, out nodeValue))
{
return(null);
}
if (nodeValue.NodeType == (int)NODE_TYPE.SUB_TREE && nodeValue.subTreeValue > 0)
{
if ((aiFunction & nodeValue.subTreeValue) <= 0)
{
InvalidSubTreeCallBack?.Invoke(nodeValue.id);
return(null);
}
}
UnityEngine.Profiling.Profiler.BeginSample("AnalysisNode CreateNode");
NodeBase nodeBase = AnalysisNode(nodeValue, iConditionCheck);
nodeBase.NodeId = nodeValue.id;
nodeBase.EntityId = entityId;
nodeBase.Priority = nodeValue.priority;
UnityEngine.Profiling.Profiler.EndSample();
if (nodeValue.NodeType == (int)NODE_TYPE.SUB_TREE && nodeValue.subTreeType == (int)SUB_TREE_TYPE.CONFIG)
{
BehaviorTreeData subTreeData = _loadConfigInfoEvent(nodeValue.subTreeConfig);
if (null != subTreeData)
{
NodeBase subTreeNode = Analysis(entityId, subTreeData, iConditionCheck, InvalidSubTreeCallBack);
NodeComposite composite = (NodeComposite)(nodeBase);
composite.AddNode(subTreeNode);
iConditionCheck.AddParameter(subTreeData.parameterList);
}
}
UnityEngine.Profiling.Profiler.BeginSample("AnalysisNode IsLeafNode");
if (!IsLeafNode(nodeValue.NodeType))
{
NodeComposite composite = (NodeComposite)nodeBase;
for (int i = 0; i < nodeValue.childNodeList.Count; ++i)
{
int childNodeId = nodeValue.childNodeList[i];
NodeBase childNode = AnalysisNode(entityId, aiFunction, data, childNodeId, iConditionCheck, InvalidSubTreeCallBack);
if (null != childNode)
{
composite.AddNode(childNode);
}
}
}
UnityEngine.Profiling.Profiler.EndSample();
return(nodeBase);
}
public void NodeAddParameter(int nodeId, NodeParameter parameter)
{
NodeValue nodeValue = BehaviorDataController.Instance.GetNode(nodeId);
if (null != nodeValue)
{
DataParameterHandler dataParameterHandler = new DataParameterHandler();
dataParameterHandler.AddParameter(nodeValue.parameterList, parameter);
}
}
void DrawNodeWindow(int id)
{
if (id >= _nodeList.Count)
{
return;
}
NodeValue nodeValue = _nodeList[id];
NodeEditor.Draw(nodeValue, BehaviorDataController.Instance.CurrentSelectId);
GUI.DragWindow();
}
public NodeAction GetAction(NodeValue nodeValue)
{
UnityEngine.Profiling.Profiler.BeginSample("GetAction");
NodeAction action = (NodeAction)CustomNode.Instance.GetNode(nodeValue.identificationName);
action.SetParameters(nodeValue.parameterList);
UnityEngine.Profiling.Profiler.EndSample();
return(action);
}
private NodeBaseInspector GetBaseInspector(NodeValue nodeValue)
{
NodeBaseInspector inspector = null;
if (!_inspectorDic.TryGetValue((NODE_TYPE)nodeValue.NodeType, out inspector))
{
inspector = nodeCompositeInspector;
}
inspector.SetNodeValue(nodeValue);
return(inspector);
}
public NodeCondition GetCondition(NodeValue nodeValue, IConditionCheck iConditionCheck)
{
UnityEngine.Profiling.Profiler.BeginSample("GetCondition1");
NodeCondition condition = (NodeCondition)CustomNode.Instance.GetNode(nodeValue.identificationName);
UnityEngine.Profiling.Profiler.EndSample();
condition.SetData(nodeValue.parameterList, nodeValue.conditionGroupList);
condition.SetConditionCheck(iConditionCheck);
return(condition);
}
private void CompositeNode(NodeValue nodeValue)
{
if (nodeValue.NodeType == (int)NODE_TYPE.CONDITION ||
nodeValue.NodeType == (int)NODE_TYPE.ACTION)
{
return;
}
EditorGUILayout.BeginHorizontal(/*"box"*/);
{
string[] nameArr = EnumNames.GetEnumNames <NODE_TYPE>();
List <string> nameList = new List <string>(nameArr);
NODE_TYPE[] removeTypeArr = new NODE_TYPE[2] {
NODE_TYPE.ACTION, NODE_TYPE.CONDITION
};
for (int i = nameList.Count - 1; i >= 0; --i)
{
for (int j = 0; j < removeTypeArr.Length; ++j)
{
NODE_TYPE type = removeTypeArr[j];
int value = EnumNames.GetEnumIndex <NODE_TYPE>(type);
string name = EnumNames.GetEnumName <NODE_TYPE>(value);
if (name.CompareTo(nameList[i]) == 0)
{
nameList.RemoveAt(i);
break;
}
}
}
nameArr = nameList.ToArray();
int index = EnumNames.GetEnumIndex <NODE_TYPE>((NODE_TYPE)nodeValue.NodeType);
if (index > nameArr.Length)
{
index -= 2;//把 条件节点、行为节点，两个节点减掉
}
if ((NODE_TYPE)nodeValue.NodeType != NODE_TYPE.SUB_TREE)
{
int result = EditorGUILayout.Popup(new GUIContent("改变节点类型"), index, nameArr);
if (result != index)
{
nodeValue.NodeType = (int)(EnumNames.GetEnum <NODE_TYPE>(result));
nodeValue.nodeName = EnumNames.GetEnumName <NODE_TYPE>(result);
nodeValue.function = NodeDescript.GetFunction((NODE_TYPE)nodeValue.NodeType);;
Debug.LogError(nodeValue.nodeName);
}
}
}
EditorGUILayout.EndHorizontal();
}
