private void CheckTransition(SkillHsmConfigTransition transition)
{
for (int i = transition.GroupList.Count - 1; i >= 0; --i)
{
SkillHsmConfigTransitionGroup group = transition.GroupList[i];
bool validGroup = false;
for (int j = group.ParameterList.Count - 1; j >= 0; --j)
{
string parameter = group.ParameterList[j];
SkillHsmConfigHSMParameter hSMParameter = transition.ParameterList.Find(a => (a.ParameterName.CompareTo(parameter) == 0));
if (null == hSMParameter)
{
group.ParameterList.RemoveAt(j);
Debug.LogError("group ParameterList remove :" + parameter);
}
else
{
validGroup = true;
}
}
if (!validGroup)
{
transition.GroupList.RemoveAt(i);
Debug.LogError("RemoveGroup :" + group.Index);
}
}
}
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);
}
}
}
public static SkillHsmConfigTransition Clone(this SkillHsmConfigTransition self)
{
SkillHsmConfigTransition newTransition = new SkillHsmConfigTransition();
newTransition.CloneFrom(self);
return(newTransition);
}
public static void CloneFrom(this SkillHsmConfigTransition self, SkillHsmConfigTransition transition)
{
self.TransitionId = transition.TransitionId;
self.ToStateId = transition.ToStateId;
for (int i = 0; i < transition.ParameterList.Count; ++i)
{
SkillHsmConfigHSMParameter parameter = transition.ParameterList[i];
self.ParameterList.Add(parameter.Clone());
}
for (int i = 0; i < transition.GroupList.Count; ++i)
{
SkillHsmConfigTransitionGroup group = transition.GroupList[i];
SkillHsmConfigTransitionGroup clone = new SkillHsmConfigTransitionGroup();
clone.Index = group.Index;
for (int j = 0; j < group.ParameterList.Count; ++j)
{
clone.ParameterList.Add(group.ParameterList[j]);
}
self.GroupList.Add(clone);
}
}
public virtual void AddTransition(SkillHsmConfigTransition transition)
{
_transitionList.Add(transition);
ConditionParameter conditionParametr = new ConditionParameter();
conditionParametr.SetGroup(transition);
_conditionParameterDic[transition.TransitionId] = conditionParametr;
}
public void SetGroup(SkillHsmConfigTransition transition)
{
for (int i = 0; i < transition.GroupList.Count; ++i)
{
SkillHsmConfigTransitionGroup transitionGroup = transition.GroupList[i];
TransitionGroupParameter group = GetParameter(transitionGroup, transition.ParameterList);
groupList.Add(group);
}
}
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();
}
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;
}
}
}
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 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);
}
}
}
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;
}
}
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);
}
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 void NodeAddTransition(SkillHsmConfigNodeData fromNode, SkillHsmConfigNodeData toNode)
{
for (int i = 0; i < fromNode.TransitionList.Count; ++i)
{
SkillHsmConfigTransition temp = fromNode.TransitionList[i];
if (temp.ToStateId == toNode.Id)
{
return;
}
}
int transitionId = -1;
for (int i = 0; i < fromNode.TransitionList.Count; ++i)
{
bool result = true;
for (int j = 0; j < fromNode.TransitionList.Count; ++j)
{
SkillHsmConfigTransition temp = fromNode.TransitionList[j];
if (i == temp.TransitionId)
{
result = false;
break;
}
}
if (result)
{
transitionId = i;
break;
}
}
if (transitionId == -1)
{
transitionId = fromNode.TransitionList.Count;
}
SkillHsmConfigTransition transition = new SkillHsmConfigTransition();
transition.TransitionId = transitionId;
transition.ToStateId = toNode.Id;
fromNode.TransitionList.Add(transition);
}
/// <summary>
/// 执行节点抽象方法
/// </summary>
/// <returns>返回执行结果</returns>
public virtual int Execute(ref bool result)
{
result = false;
#if UNITY_EDITOR
NodeNotify.NotifyExecute(NodeId, Time.realtimeSinceStartup);
#endif
int toStateId = -1;
for (int i = 0; i < _transitionList.Count; ++i)
{
SkillHsmConfigTransition transition = _transitionList[i];
ConditionParameter conditionParameter = null;
if (_conditionParameterDic.TryGetValue(transition.TransitionId, out conditionParameter))
{
result = _iconditionCheck.Condition(conditionParameter);
}
if (result)
{
toStateId = transition.ToStateId;
break;
}
}
return(toStateId);
}
private void NodeChangeParameter(int stateId, int transitionId, string newParameter)
{
SkillHsmConfigNodeData nodeValue = GetNode(stateId);
if (null == nodeValue)
{
return;
}
SkillHsmConfigHSMParameter parameter = null;
for (int i = 0; i < _HSMTreeData.ParameterList.Count; ++i)
{
SkillHsmConfigHSMParameter temp = _HSMTreeData.ParameterList[i];
if (temp.ParameterName.CompareTo(newParameter) == 0)
{
parameter = temp;
}
}
if (null == parameter)
{
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;
}
for (int i = 0; i < parameterList.Count; ++i)
{
SkillHsmConfigHSMParameter temp = parameterList[i];
if (temp.ParameterName.CompareTo(parameter.ParameterName) == 0)
{
parameterList[i] = parameter.Clone();
break;
}
}
for (int i = 0; i < parameterList.Count; ++i)
{
parameterList[i].Index = i;
}
}
private void NodeTransitionAddDelGroup(int stateId, int transitionId, int groupId, bool isAdd)
{
SkillHsmConfigNodeData nodeValue = GetNode(stateId);
if (null == nodeValue)
{
return;
}
if (isAdd)
{
for (int i = 0; i < nodeValue.TransitionList.Count; ++i)
{
SkillHsmConfigTransition transition = null;
if (nodeValue.TransitionList[i].TransitionId != transitionId)
{
continue;
}
transition = nodeValue.TransitionList[i];
for (int j = 0; j < transition.GroupList.Count + 1; ++j)
{
SkillHsmConfigTransitionGroup transitionGroup = transition.GroupList.Find(a => a.Index == j);
if (null == transitionGroup)
{
transitionGroup = new SkillHsmConfigTransitionGroup();
transitionGroup.Index = j;
transition.GroupList.Add(transitionGroup);
break;
}
}
if (transition.GroupList.Count <= 0)
{
SkillHsmConfigTransitionGroup transitionGroup = new SkillHsmConfigTransitionGroup();
transitionGroup.Index = 0;
transition.GroupList.Add(transitionGroup);
}
}
}
else
{
for (int i = 0; i < nodeValue.TransitionList.Count; ++i)
{
SkillHsmConfigTransition transition = null;
if (nodeValue.TransitionList[i].TransitionId != transitionId)
{
continue;
}
transition = nodeValue.TransitionList[i];
for (int j = 0; j < transition.GroupList.Count; ++j)
{
if (transition.GroupList[j].Index == groupId)
{
transition.GroupList.RemoveAt(j);
}
}
}
}
}
private void DrawNode(SkillHsmConfigNodeData nodeData)
{
string selectTitle = string.Empty;
int selectTransitionId = -1;
bool selectTransition = SelectTransition(nodeData, ref selectTransitionId);
selectNodeParameter = !selectTransition;
GUI.backgroundColor = selectNodeParameter ? new Color(0, 1, 0, 1) : Color.white;//
EditorGUILayout.BeginVertical("box");
{
bool oldValue = selectNodeParameter;
selectNodeParameter = EditorGUILayout.Toggle(new GUIContent("节点参数"), selectNodeParameter);
if ((!oldValue && selectNodeParameter) && HSMManager.Instance.CurrentTransitionId >= 0 && null != HSMManager.hSMChangeSelectTransitionId)
{
HSMManager.hSMChangeSelectTransitionId(-1);
}
}
EditorGUILayout.EndVertical();
GUI.backgroundColor = Color.white;
SkillHsmConfigTransition transition = null;
EditorGUILayout.BeginVertical("box");
{
EditorGUILayout.LabelField("选择转换连线查看/添加/删除参数");
for (int i = 0; i < nodeData.TransitionList.Count; ++i)
{
SkillHsmConfigTransition temp = nodeData.TransitionList[i];
string name = string.Format("转换条件参数:连线ID_{0}", temp.ToStateId);
bool lastValue = (selectTransitionId == temp.TransitionId);
if (lastValue)
{
transition = temp;
selectTitle = name;//string.Format("{0} 参数", name);
}
GUI.backgroundColor = lastValue ? new Color(0, 1, 0, 1) : Color.white;//
EditorGUILayout.BeginHorizontal("box");
{
GUIStyle guiStyle = new GUIStyle();
guiStyle.normal.textColor = lastValue ? Color.green : Color.black;
bool value = EditorGUILayout.Toggle(new GUIContent(name), lastValue);
if (value && !lastValue)
{
if (null != HSMManager.hSMChangeSelectTransitionId)
{
int id = nodeData.Id * 1000 + temp.TransitionId;
HSMManager.hSMChangeSelectTransitionId(id);
}
}
if (GUILayout.Button("复制"))
{
HSMManager.copyTransition = temp.Clone();
}
if (GUILayout.Button("粘贴"))
{
if (null != HSMManager.copyTransition)
{
HSMManager.copyTransition.TransitionId = temp.TransitionId;
HSMManager.copyTransition.ToStateId = temp.ToStateId;
temp = HSMManager.copyTransition.Clone();
nodeData.TransitionList[i] = temp;
HSMManager.copyTransition = null;
}
}
if (GUILayout.Button("删除"))
{
if (null != HSMManager.hSMNodeChangeTransition)
{
HSMManager.hSMNodeChangeTransition(nodeData.Id, temp.ToStateId, false);
}
}
}
EditorGUILayout.EndHorizontal();
GUI.backgroundColor = Color.white;
}
}
EditorGUILayout.EndVertical();
if (null != transition)
{
DrawTransitionParameter(nodeData, transition, selectTitle);
}
if (selectNodeParameter)
{
DrawNodeParameter(nodeData, selectTitle);
}
}
