private void DrawTransitionAddParameter(SkillHsmConfigNodeData nodeValue, int transitionId)
{
GUI.enabled = (transitionId >= 0);
if (GUILayout.Button("添加条件"))
{
if (HSMManager.Instance.HSMTreeData.ParameterList.Count <= 0)
{
string msg = "没有参数可添加，请先添加参数";
if (HSMNodeWindow.window != null)
{
HSMNodeWindow.window.ShowNotification(msg);
}
}
else
{
if (null != HSMManager.hSMNodeAddDelParameter)
{
SkillHsmConfigHSMParameter hSMParameter = HSMManager.Instance.HSMTreeData.ParameterList[0];
HSMManager.hSMNodeAddDelParameter(nodeValue.Id, transitionId, hSMParameter, true);
}
}
}
GUI.enabled = true;
}
private void DrawNodeParameter(SkillHsmConfigNodeData nodeData, string title)
{
EditorGUILayout.LabelField(title);
List <SkillHsmConfigHSMParameter> parametersList = nodeData.ParameterList;
Action <SkillHsmConfigHSMParameter> DelCallBack = (hSMParameter) =>
{
if (null != HSMManager.hSMNodeAddDelParameter)
{
HSMManager.hSMNodeAddDelParameter(nodeData.Id, -1, hSMParameter, false);
}
};
Action <string> ChangeParameter = (parameterName) =>
{
if (null != HSMManager.hSMNodeChangeParameter)
{
HSMManager.hSMNodeChangeParameter(nodeData.Id, -1, parameterName);
}
};
DrawParameter(nodeData, parametersList, DelCallBack, ChangeParameter, null);
GUILayout.Space(10);
EditorGUILayout.BeginVertical("box");
{
DrawNodeAddParameter(nodeData);
}
EditorGUILayout.EndVertical();
}
private void SelectTransition()
{
Event _event = Event.current;
Vector3 mousePos = _event.mousePosition;
if (_event.type != EventType.MouseDown || (_event.button != 0)) // 鼠标左键
{
return;
}
for (int i = 0; i < _nodeList.Count; i++)
{
SkillHsmConfigNodeData nodeValue = _nodeList[i];
for (int j = 0; j < nodeValue.TransitionList.Count; ++j)
{
SkillHsmConfigTransition transition = nodeValue.TransitionList[j];
int toId = transition.ToStateId;
SkillHsmConfigNodeData toNode = HSMManager.Instance.GetNode(toId);
if (null == toNode)
{
continue;
}
int transitionId = nodeValue.Id * 1000 + transition.TransitionId;
Vector3 startPos = Vector3.zero;
Vector3 endPos = Vector3.zero;
CalculateTranstion(nodeValue.Position, toNode.Position, ref startPos, ref endPos);
Vector3 AB = endPos - startPos;
Vector3 AP = mousePos - startPos;
Vector3 BP = mousePos - endPos;
float dotAP_AB = Vector3.Dot(AP, AB.normalized);
float dotBP_BA = Vector3.Dot(BP, (AB * -1).normalized);
if (dotAP_AB < 0 || dotBP_BA < 0)
{
continue;
}
float distance = Vector3.Cross(AB, AP).magnitude / AB.magnitude;
bool value = (distance < 10) && (Mathf.Abs(dotAP_AB) < AB.magnitude);
if (value)
{
if (null != HSMManager.hSMChangeSelectTransitionId)
{
int id = nodeValue.Id * 1000 + transition.TransitionId;
HSMManager.hSMChangeSelectTransitionId(id);
}
if (null != HSMManager.hSMChangeSelectId)
{
HSMManager.hSMChangeSelectId(nodeValue.Id);
}
}
//float distance = Vector3.Cross(AB, AP).magnitude / AB.magnitude;
//return distance <= (sRadius + cRadius);
}
}
}
private static SkillHsmConfigHSMTreeData FormatData(SkillHsmConfigHSMTreeData skillHsmData)
{
Dictionary <int, SkillHsmConfigNodeData> nodeDic = new Dictionary <int, SkillHsmConfigNodeData>();
for (int i = 0; i < skillHsmData.NodeList.Count; ++i)
{
SkillHsmConfigNodeData nodeValue = skillHsmData.NodeList[i];
nodeDic[nodeValue.Id] = nodeValue;
}
for (int i = 0; i < skillHsmData.NodeList.Count; ++i)
{
SkillHsmConfigNodeData nodeValue = skillHsmData.NodeList[i];
if (nodeValue.ChildIdList.Count <= 0)
{
continue;
}
for (int j = 0; j < nodeValue.ChildIdList.Count; ++j)
{
int childId = nodeValue.ChildIdList[j];
SkillHsmConfigNodeData childNode = nodeDic[childId];
if (null == childNode)
{
continue;
}
childNode.ParentId = nodeValue.Id;
}
}
return(skillHsmData);
}
private void ResetScrollPos()
{
if (_nodeList.Count <= 0)
{
return;
}
SkillHsmConfigNodeData rightmostNode = null;
SkillHsmConfigNodeData bottomNode = null;
for (int i = 0; i < _nodeList.Count; ++i)
{
SkillHsmConfigNodeData 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;
}
}
private void SetDefaultState(SkillHsmConfigNodeData nodeValue)
{
if (nodeValue.NodeType != (int)NODE_TYPE.ENTRY && nodeValue.NodeType != (int)NODE_TYPE.EXIT)
{
SetDefaultState(nodeValue.Id);
}
}
private void ClickNode(SkillHsmConfigNodeData nodeValue)
{
if (null == nodeValue)
{
return;
}
int nodeId = (null != nodeValue) ? nodeValue.Id : -1;
if (HSMManager.hSMChangeSelectId != null)
{
HSMManager.hSMChangeSelectId(nodeId);
}
if (nodeValue.NodeType == (int)NODE_TYPE.SUB_STATE_MACHINE)
{
int currentTime = (int)(Time.realtimeSinceStartup * 1000);
if (currentTime - lastClickNodeTime <= 200)
{
if (null != HSMManager.hsmOpenSubMachine)
{
HSMManager.hsmOpenSubMachine(nodeId);
}
}
lastClickNodeTime = (int)(Time.realtimeSinceStartup * 1000);
}
}
private void GetNodeAllChild(int nodeId, ref List <SkillHsmConfigNodeData> dataList)
{
List <SkillHsmConfigNodeData> childList = GetNodeChild(nodeId);
dataList.AddRange(childList);
List <int> hasChildIdList = new List <int>();
for (int i = 0; i < childList.Count; ++i)
{
SkillHsmConfigNodeData nodeValue = childList[i];
List <SkillHsmConfigNodeData> list = GetNodeChild(nodeValue.Id);
dataList.AddRange(list);
for (int j = 0; j < list.Count; ++j)
{
SkillHsmConfigNodeData childNode = list[j];
if (childNode.ChildIdList.Count > 0)
{
hasChildIdList.Add(childNode.Id);
}
}
}
for (int i = 0; i < hasChildIdList.Count; ++i)
{
GetNodeAllChild(hasChildIdList[i], ref dataList);
}
}
private string GetNodeName(SkillHsmConfigNodeData 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));
}
public string[] GetOptionArr(ref int selectIndex, ref List <int> nodeList)
{
nodeList = new List <int>();
List <string> optionList = new List <string>();
nodeList.Add(-1);
optionList.Add("Base");
selectIndex = nodeList.Count - 1;
if (HSMManager.Instance.CurrentOpenSubMachineId >= 0)
{
int nodeId = HSMManager.Instance.CurrentOpenSubMachineId;
SkillHsmConfigNodeData nodeValue = HSMManager.Instance.GetNode(nodeId);
while (null != nodeValue && nodeValue.NodeType == (int)NODE_TYPE.SUB_STATE_MACHINE)
{
nodeList.Insert(1, nodeValue.Id);
selectIndex = nodeList.Count - 1;
string name = GetNodeName(nodeValue);
optionList.Insert(1, name);
if (nodeValue.ParentId > 0)
{
nodeValue = HSMManager.Instance.GetNode(nodeValue.ParentId);
}
else
{
break;
}
}
}
return(optionList.ToArray());
}
public List <SkillHsmConfigNodeData> GetBaseNode()
{
List <SkillHsmConfigNodeData> allNodeList = GetNodeList();
List <SkillHsmConfigNodeData> drawList = new List <SkillHsmConfigNodeData>();
HashSet <int> childNodeHash = new HashSet <int>();
for (int i = 0; i < allNodeList.Count; ++i)
{
SkillHsmConfigNodeData nodeValue = allNodeList[i];
for (int j = 0; j < nodeValue.ChildIdList.Count; ++j)
{
int childId = nodeValue.ChildIdList[j];
if (!childNodeHash.Contains(childId))
{
childNodeHash.Add(childId);
}
}
}
for (int i = 0; i < allNodeList.Count; ++i)
{
SkillHsmConfigNodeData nodeValue = allNodeList[i];
if (childNodeHash.Contains(nodeValue.Id))
{
continue;
}
drawList.Add(nodeValue);
}
return(drawList);
}
private void ShowMenu(SkillHsmConfigNodeData currentNode, SkillHsmConfigNodeData nodeValue)
{
int menuType = (nodeValue != null) ? 1 : 0;
GenericMenu menu = new GenericMenu();
if (menuType == 0)
{
GenericMenu.MenuFunction2 CallBack = (object userData) => {
if (null != HSMManager.hSMAddState)
{
int subMachineId = -1;
if (HSMManager.Instance.CurrentOpenSubMachineId >= 0)
{
subMachineId = HSMManager.Instance.CurrentOpenSubMachineId;
}
HSMManager.hSMAddState((Node_Draw_Info_Item)userData, mousePosition, subMachineId);
}
};
List <Node_Draw_Info> nodeList = _drawController._HSMDrawModel.InfoList;
for (int i = 0; i < nodeList.Count; ++i)
{
Node_Draw_Info draw_Info = nodeList[i];
for (int j = 0; j < draw_Info._nodeArr.Count; ++j)
{
KeyValuePair <string, Node_Draw_Info_Item> kv = draw_Info._nodeArr[j];
string itemName = string.Format("{0}", kv.Key);
menu.AddItem(new GUIContent(itemName), false, CallBack, kv.Value);
}
}
}
else
{
if (null != currentNode && nodeValue.Id == currentNode.Id && nodeValue.NodeType != (int)NODE_TYPE.EXIT)
{
// 连线子节点
menu.AddItem(new GUIContent("Make Transition"), false, MakeTransition);
menu.AddSeparator("");
}
if (null != currentNode && (currentNode.NodeType != (int)NODE_TYPE.ENTRY && (currentNode.NodeType != (int)NODE_TYPE.EXIT)))
{
// 删除节点
menu.AddItem(new GUIContent("Delete State"), false, DeleteNode);
}
if (nodeValue.NodeType != (int)NODE_TYPE.ENTRY && nodeValue.NodeType != (int)NODE_TYPE.EXIT)
{
// 设置默认节点
menu.AddItem(new GUIContent("Set Default State"), false, SetDefaultState);
}
}
menu.ShowAsContext();
Event.current.Use();
}
private void NodeMakeTransition(SkillHsmConfigNodeData currentNode)
{
Event _event = Event.current;
mousePosition = _event.mousePosition;
if (_event.type == EventType.MouseDown)
{
if (_event.button == 0) // 鼠标左键
{
if (makeTransitionMode)
{
SkillHsmConfigNodeData nodeValue = GetMouseInNode(_nodeList);
// 如果按下鼠标时，选中了一个节点，则将 新选中根节点 添加为 selectNode 的子节点
bool nodeTypeValid = CheckTranshtion(currentNode, nodeValue);
if (null != nodeValue && currentNode.Id != nodeValue.Id && nodeTypeValid)
{
if (null != HSMManager.hSMNodeChangeTransition)
{
HSMManager.hSMNodeChangeTransition(currentNode.Id, nodeValue.Id, true);
}
}
// 取消连线状态
makeTransitionMode = false;
}
else
{
SkillHsmConfigNodeData nodeValue = GetMouseInNode(_nodeList);
if ((null != nodeValue))
{
ClickNode(nodeValue);
}
}
}
if (_event.button == 1) // 鼠标右键
{
if ((!makeTransitionMode))
{
SkillHsmConfigNodeData nodeValue = GetMouseInNode(_nodeList);
ShowMenu(currentNode, nodeValue);
}
}
}
if (makeTransitionMode && currentNode != null)
{
SkillHsmConfigRectT mouseRect = new SkillHsmConfigRectT();
mouseRect.X = mousePosition.x;
mouseRect.Y = mousePosition.y;
mouseRect.Width = 10;
mouseRect.Height = 10;
DrawNodeCurve(currentNode.Position, mouseRect, Color.black);
}
}
private void DrawTransitionParameter(SkillHsmConfigNodeData nodeData, SkillHsmConfigTransition transition, string title)
{
EditorGUILayout.BeginVertical("box");
{
if (null != transition)
{
SkillHsmConfigNodeData toNode = HSMManager.Instance.GetNode(transition.ToStateId);
string toNodeDescript = (null != toNode) ? toNode.Descript : string.Empty;
string msg = string.Format("节点{0} -> 节点{1}", nodeData.Id, transition.ToStateId);
EditorGUILayout.LabelField(msg);
}
}
EditorGUILayout.EndVertical();
int transitionId = (null != transition) ? transition.TransitionId : -1;
List <SkillHsmConfigHSMParameter> parametersList = (null != transition) ? transition.ParameterList : new List <SkillHsmConfigHSMParameter>();
Action <SkillHsmConfigHSMParameter> DelCallBack = (hSMParameter) =>
{
if (null != HSMManager.hSMNodeAddDelParameter)
{
HSMManager.hSMNodeAddDelParameter(nodeData.Id, transitionId, hSMParameter, false);
}
};
Action <string> ChangeParameter = (parameterName) =>
{
if (null != HSMManager.hSMNodeChangeParameter)
{
HSMManager.hSMNodeChangeParameter(nodeData.Id, transitionId, parameterName);
}
};
SkillHsmConfigTransitionGroup group = null;
EditorGUILayout.BeginVertical("box");
{
group = HSMTransitionGroup.DrawTransitionGroup(nodeData, transition);
DrawTransitionAddGroup(nodeData, transitionId);
}
EditorGUILayout.EndVertical();
for (int i = 0; i < parametersList.Count; ++i)
{
parametersList[i].Index = i;
}
DrawParameter(nodeData, parametersList, DelCallBack, ChangeParameter, group);
GUILayout.Space(10);
EditorGUILayout.BeginVertical("box");
{
DrawTransitionAddParameter(nodeData, transitionId);
}
EditorGUILayout.EndVertical();
}
void DrawNodeWindow(int id)
{
if (id >= _nodeList.Count)
{
return;
}
SkillHsmConfigNodeData nodeValue = _nodeList[id];
HSMNodeEditor.Draw(nodeValue, HSMManager.Instance.CurrentSelectId, HSMManager.Instance.DefaultStateId);
GUI.DragWindow();
}
public void CheckData(SkillHsmConfigHSMTreeData data)
{
for (int i = 0; i < data.NodeList.Count; ++i)
{
SkillHsmConfigNodeData nodeData = data.NodeList[i];
for (int j = 0; j < nodeData.TransitionList.Count; ++j)
{
SkillHsmConfigTransition transition = nodeData.TransitionList[j];
CheckTransition(transition);
}
}
}
private void NodeDeleteTransition(SkillHsmConfigNodeData fromNode, SkillHsmConfigNodeData toNode)
{
for (int i = 0; i < fromNode.TransitionList.Count; ++i)
{
SkillHsmConfigTransition temp = fromNode.TransitionList[i];
if (temp.ToStateId == toNode.Id)
{
fromNode.TransitionList.RemoveAt(i);
break;
}
}
}
/// 每帧绘制从 节点到所有子节点的连线
private void DrawToChildCurve(SkillHsmConfigNodeData nodeValue)
{
for (int i = nodeValue.TransitionList.Count - 1; i >= 0; --i)
{
int toId = nodeValue.TransitionList[i].ToStateId;
SkillHsmConfigNodeData toNode = HSMManager.Instance.GetNode(toId);
int transitionId = nodeValue.Id * 1000 + nodeValue.TransitionList[i].TransitionId;
Color color = (transitionId == HSMManager.Instance.CurrentTransitionId) ? (Color)(new Color32(90, 210, 111, 255)) : Color.black;
DrawNodeCurve(nodeValue.Position, toNode.Position, color);
}
}
// 删除节点
private void DeleteNode(int stateId)
{
SkillHsmConfigNodeData delNode = GetNode(stateId);
if (null == delNode)
{
return;
}
List <SkillHsmConfigNodeData> delList = new List <SkillHsmConfigNodeData>()
{
delNode
};
GetNodeAllChild(stateId, ref delList);
HashSet <int> delHash = new HashSet <int>();
for (int i = 0; i < delList.Count; ++i)
{
delHash.Add(delList[i].Id);
//Debug.LogError(delList[i].Id);
}
for (int i = NodeList.Count - 1; i >= 0; --i)
{
SkillHsmConfigNodeData nodeValue = NodeList[i];
for (int j = 0; j < nodeValue.TransitionList.Count; ++j)
{
SkillHsmConfigTransition transition = nodeValue.TransitionList[j];
if (delHash.Contains(transition.ToStateId))
{
nodeValue.TransitionList.RemoveAt(j);
}
}
for (int j = nodeValue.ChildIdList.Count - 1; j >= 0; --j)
{
int childId = nodeValue.ChildIdList[j];
if (delHash.Contains(childId))
{
nodeValue.ChildIdList.RemoveAt(j);
}
}
if (delHash.Contains(nodeValue.Id))
{
NodeList.RemoveAt(i);
//Debug.LogError("Remove:" + nodeValue.Id);
}
}
}
public SkillHsmConfigNodeData GetNode(int stateId)
{
for (int i = 0; i < NodeList.Count; ++i)
{
SkillHsmConfigNodeData nodeValue = NodeList[i];
if (nodeValue.Id == stateId)
{
return(nodeValue);
}
}
return(null);
}
private void NodeAddDelParameter(int stateId, int transitionId, SkillHsmConfigHSMParameter parameter, bool isAdd)
{
SkillHsmConfigNodeData nodeValue = GetNode(stateId);
if (null == nodeValue)
{
return;
}
List <SkillHsmConfigHSMParameter> parameterList = new List <SkillHsmConfigHSMParameter>();
if (transitionId >= 0)
{
SkillHsmConfigTransition transition = null;
for (int i = 0; i < nodeValue.TransitionList.Count; ++i)
{
if (nodeValue.TransitionList[i].TransitionId == transitionId)
{
transition = nodeValue.TransitionList[i];
break;
}
}
if (null == transition)
{
return;
}
parameterList = transition.ParameterList;
}
else
{
parameterList = nodeValue.ParameterList;
}
if (isAdd)
{
AddParameter(parameterList, parameter, true);
}
else
{
DelParameter(parameterList, parameter);
}
for (int i = 0; i < parameterList.Count; ++i)
{
SkillHsmConfigHSMParameter p = parameterList[i];
p.Index = i;
}
}
// 删除节点
private void DeleteNode()
{
SkillHsmConfigNodeData nodeValue = GetMouseInNode(_nodeList);
if (!EditorUtility.DisplayDialog("提示", "确定要删除节点吗", "Yes", "No"))
{
return;
}
if (null != HSMManager.hSMDeleteNode)
{
HSMManager.hSMDeleteNode(nodeValue.Id);
}
}
private void SetDefaultState()
{
SkillHsmConfigNodeData nodeValue = GetMouseInNode(_nodeList);
if (null == nodeValue)
{
return;
}
if (null != HSMManager.hSMSetDefaultState)
{
HSMManager.hSMSetDefaultState(nodeValue.Id);
}
}
private void DrawTransitionAddGroup(SkillHsmConfigNodeData nodeValue, int transitionId)
{
if (transitionId < 0)
{
return;
}
if (GUILayout.Button("添加组"))
{
if (null != HSMManager.hSMNodeTransitionAddDelGroup)
{
HSMManager.hSMNodeTransitionAddDelGroup(nodeValue.Id, transitionId, -1, true);
}
}
}
public static SkillHsmConfigHSMTreeData UpdateData(SkillHsmConfigHSMTreeData skillHsmData)
{
HashSet <string> useParameter = new HashSet <string>();
for (int i = 0; i < skillHsmData.NodeList.Count; ++i)
{
SkillHsmConfigNodeData nodeData = skillHsmData.NodeList[i];
for (int j = 0; j < nodeData.TransitionList.Count; ++j)
{
SkillHsmConfigTransition transition = nodeData.TransitionList[j];
for (int k = 0; k < transition.GroupList.Count; ++k)
{
SkillHsmConfigTransitionGroup transitionGroup = transition.GroupList[k];
for (int n = 0; n < transitionGroup.ParameterList.Count; ++n)
{
string parameter = transitionGroup.ParameterList[n];
if (!useParameter.Contains(parameter))
{
useParameter.Add(parameter);
}
if (parameter.CompareTo("ForcedAbortSkill") == 0)
{
Debug.LogError(skillHsmData.FileName + " ForcedAbortSkill:" + nodeData.Id + " " + transition.ToStateId);
}
if (parameter.CompareTo("ForcedAbortSkillToFish") == 0)
{
Debug.LogError(skillHsmData.FileName + " ForcedAbortSkillToFish:" + nodeData.Id + " " + transition.ToStateId);
}
}
}
}
}
for (int k = skillHsmData.ParameterList.Count - 1; k >= 0; --k)
{
SkillHsmConfigHSMParameter parameter = skillHsmData.ParameterList[k];
if (!useParameter.Contains(parameter.ParameterName))
{
Debug.LogError(skillHsmData.FileName + " " + parameter.ParameterName + " " + parameter.CNName);
skillHsmData.ParameterList.RemoveAt(k);
}
}
return(skillHsmData);
}
public void Draw(SkillHsmConfigNodeData nodeValue)
{
if (null == nodeValue)
{
EditorGUILayout.LabelField("未选择节点");
return;
}
EditorGUILayout.BeginVertical("box");
{
//string nodeId = string.Format("节点 ID:{0}", nodeValue.Id);
//EditorGUILayout.LabelField(nodeId);
int index = EnumNames.GetEnumIndex <NODE_TYPE>((NODE_TYPE)nodeValue.NodeType);
string name = EnumNames.GetEnumName <NODE_TYPE>(index);
name = string.Format("节点类型:{0}", name);
EditorGUILayout.LabelField(name);
if (nodeValue.Identification > 0)
{
CustomIdentification customIdentification = CustomNode.Instance.GetIdentification((IDENTIFICATION)nodeValue.Identification);
string typeName = string.Format("类 型:{0}", customIdentification.Name);
EditorGUILayout.LabelField(typeName);
string className = string.Format("类 名:{0}", customIdentification.Type.Name);
EditorGUILayout.LabelField(className);
//string identificationName = string.Format("类标识 :{0}", nodeValue.Identification);
//EditorGUILayout.LabelField(identificationName);
}
GUILayout.Space(5);
EditorGUILayout.BeginHorizontal();
{
EditorGUILayout.LabelField("节点名:", GUILayout.Width(50));
nodeValue.NodeName = EditorGUILayout.TextField(nodeValue.NodeName, GUILayout.ExpandWidth(true));
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.LabelField("节点描述:");
nodeValue.Descript = EditorGUILayout.TextArea(nodeValue.Descript, GUILayout.Height(30));
GUILayout.Space(5);
}
EditorGUILayout.EndVertical();
DrawNode(nodeValue);
}
// 获取鼠标所在位置的节点
private SkillHsmConfigNodeData GetMouseInNode(List <SkillHsmConfigNodeData> nodeList)
{
SkillHsmConfigNodeData selectNode = null;
for (int i = 0; i < nodeList.Count; i++)
{
SkillHsmConfigNodeData nodeValue = nodeList[i];
// 如果鼠标位置 包含在 节点的 Rect 范围，则视为可以选择的节点
if (RectTExtension.RectTToRect(nodeValue.Position).Contains(mousePosition))
{
selectNode = nodeValue;
break;
}
}
return(selectNode);
}
private bool SelectTransition(SkillHsmConfigNodeData nodeData, ref int id)
{
bool selectTransition = false;
for (int i = 0; i < nodeData.TransitionList.Count; ++i)
{
SkillHsmConfigTransition temp = nodeData.TransitionList[i];
selectTransition = (nodeData.Id * 1000 + temp.TransitionId) == HSMManager.Instance.CurrentTransitionId;
if (selectTransition)
{
id = temp.TransitionId;
break;
}
}
return(selectTransition);
}
private bool CheckTranshtion(SkillHsmConfigNodeData fromNode, SkillHsmConfigNodeData toNode)
{
if (null == toNode)
{
return(false);
}
if (toNode.NodeType == (int)NODE_TYPE.ENTRY)
{
return(false);
}
if (fromNode.NodeType == (int)NODE_TYPE.ENTRY && toNode.NodeType == (int)NODE_TYPE.EXIT)
{
return(false);
}
return(true);
}
// 绘制节点
private void DrawNodeWindows()
{
Action CallBack = () =>
{
for (int i = 0; i < _nodeList.Count; i++)
{
SkillHsmConfigNodeData nodeValue = _nodeList[i];
int index = EnumNames.GetEnumIndex <NODE_TYPE>((NODE_TYPE)nodeValue.NodeType);
string name = EnumNames.GetEnumName <NODE_TYPE>(index);
name = string.Format("{0}_{1}", name, nodeValue.Id);
Rect rect = GUI.Window(i, RectTExtension.RectTToRect(nodeValue.Position), DrawNodeWindow, name);
nodeValue.Position = RectTExtension.RectToRectT(rect);
DrawToChildCurve(nodeValue);
}
};
_treeNodeWindow.DrawWindow(CallBack);
}
